Hilo de comparación de hilo de Java, ejecutable, llamable
Java usa la clase de subprocesos para representar hilos, y todos los objetos de campo deben ser instancias de la clase de subprocesos o su subclase. La función de cada hilo es completar una determinada tarea, que en realidad es ejecutar un flujo de programa. Java usa cuerpos de ejecución de hilos para representar este flujo de programa.
1. Heredar la clase de hilo para crear hilo
Los pasos para iniciar múltiples lectura son los siguientes:
(1) Defina la subclase de la clase de hilo y anula el método run () de la clase. El cuerpo del método del método run () representa las tareas que el hilo de clase debe completar. Por lo tanto, el método run () se llama cuerpo de ejecución de hilo.
(2) Cree una instancia de la subclase de hilo, es decir, cree un objeto de subproceso.
(3) Llame al método Star () del hilo para iniciar el hilo.
Los códigos relevantes son los siguientes:
/ *** heredar la clase interna de hilo para comprar boletos, por ejemplo*/ public class FirstThread extiende el hilo {private int i; Ticket privado int = 10; @Override public void run () {for (; i <20; i ++) {// Al heredar el hilo, use esto directamente para obtener el hilo actual, getName () obtenga el nombre del hilo actual // log.d (etiqueta, getName ()+""+i); if (this.ticket> 0) {log.e (etiqueta, getName () + ", ticket selling: ticket =" + ticket--); }}}} private void starticketThread () {log.d (etiqueta, "starticketThread,"+thread.currentThread (). getName ()); FirstThread Thread1 = new FirstThread (); FirstTread Thread2 = new FirstThread (); FirstTread Thread3 = new FirstThread (); Thread1.Start (); thread2.start (); thread3.start (); // Abra 3 hilos para comprar boletos, cada hilo vendió 10 boletos y un total de 30 boletos}Resultados de ejecución:
Puede ver que las variables de voto ingresadas por 3 hilos no son continuas. Nota: Ticket es una propiedad de instancia de FirstThread, no una variable local, pero debido a que el programa debe crear un objeto FirstThread cada vez que crea un objeto de subproceso, todos los hilos múltiples no comparten los atributos de la instancia.
2. Implemente la interfaz ejecutable para crear hilos
Nota: Implementos de hilo de clase pública ejecutables
(1) Defina la clase de implementación de la interfaz ejecutable y anula el método run () de la interfaz. El cuerpo del método del método run () también es el cuerpo de ejecución de hilo del hilo.
(2) Cree una instancia de la clase de instancia runnable. Esta instancia se usa como un objetivo de subproceso para crear un objeto de subprocesos. El objeto de hilo es el objeto real.
Los códigos relevantes son los siguientes:
/ ** * Implemente la interfaz runnable y cree una clase de hilo */ public class SETTHREAD implementos runnable {private int i; Ticket privado int = 100; @Override public void run () {for (; i <20; i ++) {// Si la clase de subproceso implementa la interfaz runnable // obtiene el subproceso actual, solo puede usar thread.currentThread () para obtener el nombre de hilo actual log.d (tag, hilo.currentThread (). GetName ()+"+i); if (this.ticket> 0) {log.e (tag, thread.currentThread (). getName () + ", ticket selling: ticket =" + ticket--); }}}} private void starticketThread2 () {log.d (etiqueta, "starticketThread2,"+thread.currentThread (). getName ()); SECHTHREAD SECHINTHREAD = new SETHTHREAD (); // Crear un nuevo hilo a través de un nuevo hilo (objetivo, nombre) Nuevo hilo (SECHESTHREAD, "BOTALLO BOTKEP 1"). Start (); nuevo Thread (SecondThread, "Comprador de boletos 2"). Start (); nuevo Thread (SecondThread, "Comprador de boletos 3"). Start (); // Aunque se abrieron 3 hilos, solo se compraron 100 boletos en total}Resultados de ejecución:
Puede ver que las variables de voto ingresadas por 3 subprocesos son continuas, y múltiples hilos pueden compartir las propiedades de la instancia de la clase de subprocesos utilizando la interfaz Runnable. Esto se debe a que de esta manera, el objeto ejecutable creado por el programa es solo el objetivo de un hilo, y varios subprocesos pueden compartir el mismo objetivo, por lo que múltiples subprocesos pueden compartir las propiedades de instancia de la misma clase de hilo (que en realidad debería ser la clase de destino del hilo).
3. Cree hilos usando Callable and Future
A partir de Java 5, Java proporciona una interfaz invocable, que es una versión mejorada de Runnable. Callable proporciona un método de clase llamado () que puede usarse como un cuerpo de ejecución de hilos, pero el método de llamada () es más potente.
(1) El método de llamada () puede tener un valor de retorno (2) El método de llamada () puede declarar una excepción lanzada
Por lo tanto, podemos proporcionar un objeto llamable como el objetivo de subproceso, y el ejecutor del subproceso es el método de llamada () del objeto invocable. Al mismo tiempo, Java 5 proporciona la interfaz futura para representar el valor de retorno del método de llamada () en la interfaz invocable, y proporciona una clase de implementación de FutureTask. Esta clase de implementación implementa la interfaz futura e implementa la interfaz ejecutable, un objetivo que puede usarse como una clase de subprocesos.
Los pasos de inicio son los siguientes:
(1) Cree una clase de implementación de la interfaz llamable e implementa el método de llamada (). El método de llamada () se utilizará como el cuerpo de ejecución del hilo, y el método de llamada () tiene un valor de retorno.
(2) Cree una instancia de la clase de implementación llamable y use la clase FUTURETASK para envolver el objeto invocable. El objeto FutureTask encapsula el valor de retorno del método de llamada ().
(3) Crear e iniciar un nuevo hilo utilizando el objeto FutureTask como el objetivo del objeto de subproceso.
(4) Llame al método get () del objeto FutureTask para obtener el valor de retorno después de ejecutar el hilo infantil.
Los códigos relevantes son los siguientes:
/ *** Use llameable para implementar la clase de hilo*/ public class Tharterthread implementa Callable <Integer> {private int ticket = 20; @Override public Integer Call () {for (int i = 0; i <10; i ++) {// Obtener el hilo actual, solo puede usar Thread.CurrentThread () para obtener el nombre de subproceso actual // log.d (tag, thread.currentThread (). GetName ()+"+i); if (this.ticket> 0) {log.e (tag, thread.currentThread (). getName () + ", tickets: ticket =" + ticket--); }} Ticket de retorno; }} private void starCallableThread () {ThirdThread ThirdThread = new ThirdThread (); FUTURETASK <Integer> tarea = new FutUreTask <Integer> (tercerthread); nuevo hilo (tarea, "hilo con valor de retorno"). start (); intente {Integer Integer = task.get (); Log.d (etiqueta, "starCallableThread, el valor de retorno del hilo infantil ="+entero); } catch (InterruptedException e) {E.PrintStackTrace (); } catch (ExecutionException e) {E.PrintStackTrace (); }}Resultados de ejecución:
Nota: El método de llamada de llamadas () permite que las declaraciones arrojen excepciones y permitan valores de retorno.
El programa finalmente llama al método get () del objeto FutureTask para devolver el valor de retorno del método de llamada (), lo que hace que el hilo principal se bloquee hasta que el método de llamada () termine y regrese.
4. Comparación de tres maneras
Crear múltiples subprocesos heredando la clase de subprocesos
Desventajas: la clase de hilo ha sido heredada no puede heredarse de otras clases de padres.
Ventajas: fácil de escribir
Crear múltiples subprocesos utilizando el método de heredar interfaces ejecutables y llamables
Desventajas: la programación es un poco complicada. Si necesita acceder al hilo actual, debe usar thread.currentThread ()
Ventajas:
(1) También puede heredar otras clases (2) múltiples hilos pueden compartir un objeto objetivo, por lo que es muy adecuado para múltiples hilos idénticos para manejar el mismo recurso, separando así la CPU, el código y los datos para formar un modelo claro, que refleja mejor la idea de clase orientada al objeto.
Gracias por leer, espero que pueda ayudarte. ¡Gracias por su apoyo para este sitio!