Primeiro tente o pool de threads java

Grupo de discussão

Crie vários threads com antecedência, coloque-os no pool de threads com antecedência, obtenha-os diretamente quando usados ​​e coloque-os de volta no pool após o uso. Pode evitar a criação e destruição freqüentes e realizar a reutilização.

beneficiar

• Melhore a velocidade de resposta
• Reduza o consumo de recursos
• Facilite o gerenciamento de tópicos
  • corePoolSize: o tamanho do pool principal
  • maximunPoolSize: número máximo de threads
  • keepAliveTime: tempo para manter vivo

1.ExecutorService

public interface ExecutorService
extends Executor

Um Executorterminal e método de gerenciamento podem ser usados ​​para rastrear uma ou mais tarefas assíncronas que geram Futuremétodo de fornecimento de progresso .

Um ExecutorServicepode ser fechado, o que o fará rejeitar novas tarefas. ExecutorServiceDois métodos diferentes são fornecidos para o fechamento . Este método permitirá que shutdown()tarefas enviadas anteriormente sejam encerradas antes da execução, enquanto o shutdownNow()método evita esperar que a tarefa comece a tentar interromper a tarefa em execução no momento. No encerramento, um executor não tem tarefas ativas, nenhuma tarefa esperando para ser executada e nenhuma nova tarefa a ser enviada. Um não utilizado ExecutorServicedeve ser fechado para permitir a recuperação de seus recursos.

O método de submitextensão de método base Executor.execute(Runnable)cria e retorna um método que Futurepode cancelar a execução e / ou esperar pela conclusão. A forma mais comum de execução de métodos invokeAnye invokeAllcorpos de execução, uma coleção de tarefas executadas e, em seguida, aguardar que pelo menos um ou todos eles sejam concluídos. (As classes ExecutorCompletionServicepodem ser usadas para escrever esses métodos. Variantes personalizadas)

A Executorsclasse fornece o método de fábrica do serviço de execução fornecido por este pacote.

Exemplos de uso

Aqui está um pool de threads de threads de solicitação de serviço em um serviço de rede. Ele usa o Executors.newFixedThreadPool(int)método de fábrica pré-configurado :

 class NetworkService implements Runnable {
   private final ServerSocket serverSocket;
   private final ExecutorService pool;

   public NetworkService(int port, int poolSize)
       throws IOException {
     serverSocket = new ServerSocket(port);
     pool = Executors.newFixedThreadPool(poolSize);
   }

   public void run() { // run the service
     try {
       for (;;) {
         pool.execute(new Handler(serverSocket.accept()));
       }
     } catch (IOException ex) {
       pool.shutdown();
     }
   }
 }

 class Handler implements Runnable {
   private final Socket socket;
   Handler(Socket socket) { this.socket = socket; }
   public void run() {
     // read and service request on socket
   }
 }

O método a seguir para fechar ExecutorServiceem dois estágios chamando a shutdowntarefa de rejeição de entrada e, em seguida shutdownNow, chame , se necessário, cancele quaisquer tarefas remanescentes:

 void shutdownAndAwaitTermination(ExecutorService pool) {
   pool.shutdown(); // Disable new tasks from being submitted
   try {
     // Wait a while for existing tasks to terminate
     if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
       pool.shutdownNow(); // Cancel currently executing tasks
       // Wait a while for tasks to respond to being cancelled
       if (!pool.awaitTermination(60, TimeUnit.SECONDS))
           System.err.println("Pool did not terminate");
     }
   } catch (InterruptedException ie) {
     // (Re-)Cancel if current thread also interrupted
     pool.shutdownNow();
     // Preserve interrupt status
     Thread.currentThread().interrupt();
   }
 }

Efeito de consistência de memória: um acontecimento antes de qualquer ação executar um thread de tarefa de ação antes que uma Runnableou Callabletarefa seja enviada , de modo que o resultado será aprovado .ExecutorService Future.get()

2.Executores

public class Executors
extends Object

Para Executor, ExecutorService, ScheduledExecutorService, ThreadFactoryplantas e métodos práticos, e Callableas classes são definidas no pacote. Esta categoria suporta os seguintes métodos:

• O método cria e retorna uma ExecutorServicedefinição de configuração comumente usada.
• O método cria e retorna uma ScheduledExecutorServicedefinição de configuração comumente usada.
• O método cria e retorna um serviço de "invólucro" para que o método de implementação específico de refatoração não seja.
• O método cria e retorna um thread recém-criado ThreadFactorydefinido para um estado conhecido.
• O método cria e retorna um Callableformulário fechado que pode ser usado para executar o método Callable.

3. Código

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    
    

    public static void main(String[] args) {
    
    
        //1.创建服务
        ExecutorService service = Executors.newFixedThreadPool(10);

        //2.执行服务
        service.execute(new Pools());
        service.execute(new Pools());
        service.execute(new Pools());
        service.execute(new Pools());
        service.execute(new Pools());
        service.execute(new Pools());
        service.execute(new Pools());
        service.execute(new Pools());
        service.execute(new Pools());
        service.execute(new Pools());
//        service.execute(new Pools());多于数目并不会创建，也不会报错
//        service.execute(new Pools());
//        service.execute(new Pools());

        //3.结束服务
        service.shutdown();


    }

}

class Pools implements Runnable{
    
    
    @Override
    public void run() {
    
    
        System.out.println(Thread.currentThread().getName());
    }
}