El primer método es heredar la clase Thread y luego reescribir el método de ejecución y luego llamar al método de inicio. Debido a que Java implementa múltiples implementaciones con herencia única, no se recomienda usar este método. El código es el siguiente:
public class Demo extends Thread{
public static void main(String[] args) {
new Demo().start();
}
@Override
public void run() {
System.out.println("继承Thread类实现多线程");
}
}
El segundo método es implementar la interfaz Runnable. Este método se usa más. El código es el siguiente:
public class Demo2 implements Runnable{
public static void main(String[] args) {
new Thread(new Demo2()).start();
}
@Override
public void run() {
System.out.println("实现Runnable接口的多线程");
}
}
El tercer método es implementar la interfaz invocable. El método de ejecución de este método tiene un valor de retorno. El código es el siguiente:
public class Demo3 implements Callable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask task=new FutureTask(new Demo3());
new Thread(task).start();
System.out.println(task.get());
}
@Override
public String call() throws Exception {
return "实现Callable接口的多线程";
}
}
El cuarto método es usar el grupo de subprocesos, el código es el siguiente:
public class Demo4 {
public static void main(String[] args) {
ExecutorService executorService= Executors.newCachedThreadPool();
executorService.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程池实现多线程");
}
});
executorService.shutdown();
}
}
De lo anterior, podemos ver que todas las llamadas a subprocesos utilizan el método start (), por lo que llamar directamente al método run () puede generar el resultado, pero hay una diferencia esencial, porque llamar al método start () aumentará el número de subprocesos actuales Incrementa, y simplemente no es posible llamar al método run () El método start () en realidad incluye la llamada al método run ().
