Varias formas de lograr multihilo

• Heredar hilo

  Ventajas:

  1. Código simple, operación directa

  2. Sin valor de retorno, no puede heredar otras clases después de heredar una clase, escasa escalabilidad

     public class ThreadTest  {
         public static void main(String[] args) {
             MyThread myThread=new MyThread();
             myThread.setName("thread1");
             myThread.start();
     
             System.out.println("主线程:"+Thread.currentThread().getName());
         }
     }
     class MyThread extends Thread{
         @Override
         public void run() {
             System.out.println("run");
         }
     }
     

• Implemente la interfaz Runnable

  Ventajas:

  1. Puede implementar múltiples interfaces y puede heredar una clase

  2. Sin valor de retorno, no se puede iniciar directamente, necesita construir una instancia de Thread

     public class RunnableTest {
         public static void main(String[] args) {
             MyRunnable myRunnable=new MyRunnable();
             Thread thread= new Thread(myRunnable);
             thread.start();
         }
     }
     class MyRunnable implements Runnable{
     
         @Override
         public void run() {
             System.out.println("run");
         }
     }
     

• Clase interna anónima

     public static void main(String[] args) {
		              new Thread(()->{
		                  System.out.println("run");
		              },"thread1").start();
		          }

• Llamable y FutureTask

  • Cree una clase de implementación de la interfaz invocable, implemente el método de llamada, combine la clase FutureTask para ajustar el objeto invocable e implemente subprocesos múltiples
  • Ventajas: valor de retorno, buena escalabilidad

  public class CalAndFuture {
        public static void main(String[] args) throws ExecutionException  {
            MyTask myTask=new MyTask();
            FutureTask<Object> futureTask=new FutureTask<>(myTask);
    
            //futureTask继承了Runnable，可以放在Thread中启动执行
            Thread thread=new Thread(futureTask);
            thread.setName("thread1");
            thread.start();
    
            try {
                System.out.println(futureTask.get());//获取返回值
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    }
    class MyTask implements Callable<Object>{
    
        @Override
        public Object call() throws Exception {
            System.out.println("callable");
            return "sth";
        }
    }
  

• Cree un hilo a través de la
  interfaz Runnable personalizada del grupo de hilos, implemente el método de ejecución, cree un grupo de hilos, llame al método de ejecución y pase el objeto

• Ventajas
  Alta seguridad, reutilizar hilos

  public class Pool {
      public static void main(String[] args) {
          ExecutorService executorService= Executors.newFixedThreadPool(3);
  
          for (int i = 0; i < 10; i++) {
  
          executorService.execute(new ThreadDemo());
          }
          executorService.shutdown();
      }
  }
  class ThreadDemo implements Runnable{
  
      @Override
      public void run() {
          System.out.println("ThreadPool+Runnable");
      }
  }
  

  El grupo de subprocesos no permite el uso de Ejecutores para crear, pero a través del Ejecutor de ThreadPool. Esta forma de procesamiento hace que los estudiantes sean más claros sobre las reglas de ejecución del grupo de subprocesos y evita el riesgo de agotamiento de los recursos.
  Descripción
  1) FixedThreadPool
  utiliza LinkedBlockingQueue internamente, lo cual está permitido por defecto La longitud de la cola de solicitudes es Integer. MAX_VALUE, que puede acumular una gran cantidad de solicitudes de tareas, lo que resulta en OOM

  2) CachedThreadPool

  La longitud de la cola de solicitud permitida es Integer. MAX VALUE, que puede crear una gran cantidad de subprocesos, lo que resulta en OOM

ThreadPoolExecutor executor=new ThreadPoolExecutor(6,30,0L, TimeUnit.MINUTES,new LinkedBlockingDeque<>());
              
      
              for (int i = 0; i < 10; i++) {
      
                  executor.execute(new ThreadDemo());
              }
              executor.shutdown();

El grupo de hilos se detalla en las notas de la serie del grupo de hilos

• computación en serie java8

   list.parallelStream().forEach(System.out::print);

• Método asíncrono @Async en Spring