Este ejemplo comparte tres formas de implementar múltiples subprocesos en Java para su referencia. El contenido específico es el siguiente
import java.util.concurrent.callable; import java.util.concurrent.futureTask; public class Main {public static void main (string [] args) {// método 1: inherit thread int i = 0; // for (; i <100; i ++) {// system.println (hilo.currentThead (). i); // if (i == 5) {// threiftextendSthread thiftExtendSthread = new ThreadExtendSThread (); // ThreadExtendSThread.Start (); //} //} // Método 2: implementar runnable // for (i = 0; i <00; i ++) {// system.println (horte.currentThread (). i); // if (i == 5) {// runnable runnable = new ThreadImplementsRunnable (); // new Thread (runnable) .start (); //} //} // Método 3: Implemente la interfaz llamable Callable <Inger> Callable = New ThreadMplementsCallable (); FUTURETASK <Integer> FUTURETASK = new FutureTask <> (llamable); para (i = 0; i <100; i ++) {System.out.println (Thread.CurrentThread (). GetName () + "" + I); if (i == 5) {nuevo hilo (FutureTask) .Start (); nuevo hilo (FutUreTask) .Start (); }} try {System.out.println ("FutUreTask ruturn:" + futuretask.get ()); } catch (Exception e) {E.PrintStackTrace (); }}} Método 1, heredar del hilo
public class ThreadExtendSthread extiende el hilo {private int i; @Override public void run () {for (; i <100; i ++) {system.out.println (getName () + "" + i); }}}El método Ejecutar es el cuerpo de ejecución de subprocesos, y el objeto ThreadextendSthread es el objeto de subproceso.
Método 2: implementar la interfaz ejecutable
clase pública ThreadImplementsRunnable Implements runnable {private int i; @Override public void run () {for (; i <100; i ++) {System.out.println (Thread.CurrentThread (). GetName () + "" + i); }}}El método de ejecución es el cuerpo de ejecución de hilo. Al usarlo, un objeto de subproceso es nuevo y el objeto ejecutable se pasa al objeto de subproceso como un objetivo. Y el mismo objeto ejecutable se puede usar como objetivo para múltiples hilos, y estos hilos comparten variables de instancia del objeto ejecutable.
Método 3: Implementar la interfaz invocable
import java.util.concurrent.callable; public class ThreadImplementScallable implementa Callable <Integer> {private int i; @Override public Integer Call () lanza la excepción {for (; i <100; i ++) {system.out.println (thread.currentThread (). GetName () + "" + i); } return i; }}La interfaz llamable es similar a la interfaz ejecutable, pero es más fuerte que la otra parte. El cuerpo de ejecución de hilos es un método de llamada, que tiene un valor de retorno y puede lanzar excepciones. Cuando se use, envuelva el objeto llamable como un objeto FuturetAk, especifique el tipo de valor de retorno a través de Generics. Puede llamar al método GET de FUTURETASK para recuperar el resultado de la ejecución.
Lo anterior se trata de este artículo, espero que sea útil para el aprendizaje de todos.