Recientemente, aprendí y estudié el uso de Java Multi-Threading al hacer optimización del código, y luego lo resumí después de leer las ideas de los novatos.
1. Heredar la clase de subprocesos para implementar múltiples subprocesos
Aunque el método que hereda la clase de subprocesos se enumera como un método de implementación de múltiples hilos, el subproceso es esencialmente una instancia de la interfaz ejecutable, que representa una instancia de un hilo, y la única forma de iniciar un hilo es a través del método de instancia Start () de la clase de subprocesos. El método Start () es un método nativo que iniciará un nuevo hilo y ejecutará el método run (). Este método es muy simple de implementar múltiples subprocesos. Al extender directamente el hilo a través de su propia clase y reescribir el método run (), puede iniciar un nuevo hilo y ejecutar el método run () que define. Por ejemplo:
Public Class MyThread extiende el hilo {public void run () {System.out.println ("mythread.run ()"); }} Comience el hilo en el lugar correcto de la siguiente manera:
MyThread myThread1 = new MyThread (); MyThread myThread2 = new MyThread (); mythread1.start (); mythread2.start ();
2. Implemente la interfaz ejecutable para implementar múltiples subprocesos
Si su clase ya extiende otra clase, no puede extender el hilo directamente. En este momento, debe implementar una interfaz ejecutable, como sigue:
Public Class MyThread extiende otros implementos de Clase Runnable {public void run () {System.out.println ("mythread.run ()"); }} Para comenzar Mythread, primero debe instanciar un hilo y pasar en su propia instancia de Mythread:
Mythread myThread = new MyThread (); Thread Thread = New Thread (MyThread); Thread.Start ();
De hecho, cuando se pasa un parámetro de destino ejecutable al hilo, el método run () de hilo llamará a target.run (), consulte el código fuente JDK:
public void run () {if (target! = null) {target.run (); }} 3. Use ExecutorService, llamable y futuro para lograr el subcontrol múltiple con resultados de retorno
EjecutorService, llamables y futuros objetos son en realidad clases funcionales en el marco del ejecutor. Esta es una explicación muy detallada del marco. El hilo que devuelve el resultado es una nueva característica introducida en JDK1.5. De hecho, es muy práctico. Con esta función, no necesito pasar por muchos problemas para obtener el valor de retorno, e incluso si se implementa, puede estar lleno de lagunas.
Las tareas que pueden devolver los valores deben implementar la interfaz invocable y, de manera similar, las tareas que no devuelven los valores deben tener la interfaz ejecutable. Después de ejecutar la tarea invocable, puede obtener un objeto futuro. Llame al objeto para que el objeto devuelva por la tarea invocable. Combinado con el servicio de ejecutores de la interfaz de grupo de hilos, puede darse cuenta de la legendaria múltiple subproceso con el resultado de retorno. A continuación se muestra un ejemplo de prueba completo de múltiples subprocesos con resultados devueltos. Si lo ha verificado en JDK1.5, puede usarlo directamente. El código es el siguiente:
import java.util.concurrent.*; import java.util.date; import java.util.list; import java.util.arrayList; / *** Hilo con valor de retorno*/ @SupplesSwarnings ("no facturado") Prueba de clase pública {public static void main (string [] args) lanza ExecutionException, InterruptedException { System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Create a thread pool ExecutorService pool = Ejecuts.NewFixedThreadPool (Task -Size); System.out.println (">>>" + f.get (). ToString ()); // Obtenga los resultados en ejecución de todas las tareas concurrentes para (Future F: List) {// Obtenga el valor de retorno de la tarea del objeto futuro y la envíe al sistema de consola.out.println (">>>" + f.get (). ToString ()); } Fecha fecha2 = nueva fecha (); System.out.println("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- MyCallable (String TaskNum) {this.TaskNum = TaskNum; datetmp1.gettime (); Descripción del código:
En el código anterior, la clase de ejecutores proporciona una serie de métodos de fábrica para crear el grupo de subprocesos, y los grupos de subprocesos devueltos implementan la interfaz EjecutorService.
Public Static Executorservice NewfixedThreadPool (int nthreads)
Crea un grupo de hilos con un número fijo de hilos.
Public static ejecutorservice NewCachedThreadPool ()
Cree un grupo de subprocesos en caché, llamando a Execute reutilizará los subprocesos construidos previamente (si el hilo está disponible). Si el hilo existente no está disponible, cree un nuevo hilo y agréguelo a la piscina. Terminar y eliminar las hilos del caché que no se han utilizado durante 60 segundos.
Public static ejecutorservice NewsingLethreadExecutor ()
Cree un ejecutor único.
Public static programedExecutorService NewsCheduledThreadPool (int corepoolsize)
Cree un grupo de subprocesos que admita la ejecución de tareas cronometradas y periódicas, que puede usarse en la mayoría de los casos en lugar de la clase de temporizador.
EXECTORSERVICE proporciona el método SUBPIT (), que pasa un futuro llamable o ejecutable y que regrese. Si el grupo de subprocesos de fondo del Ejecutor no ha completado el cálculo llamable, esta llamada devuelve el método get () del objeto futuro, que bloqueará hasta que se complete el cálculo.