método newCachedThreadPool

Outro tipo de pool de threads é "em cache". Esses pools de encadeamentos são tão comumente usados ​​quanto os fixos.

Conforme indicado pelo nome, esse tipo de pool de encadeamentos armazena encadeamentos em cache. Ele mantém os threads não utilizados ativos por um tempo limitado para reutilizar esses threads para executar novas tarefas. Esse pool de threads é melhor para quando temos uma quantidade razoável de trabalho leve.

O significado de "alguma quantia razoável" é bastante amplo, mas você deve saber que esse pool não é adequado para todas as tarefas. Por exemplo, suponha que queremos criar um milhão de tarefas. Mesmo que cada um leve uma quantidade muito pequena de tempo, ainda usaremos uma quantidade irracional de recursos e degradaremos o desempenho. Também devemos evitar esses pools quando o tempo de execução for imprevisível, por exemplo, com tarefas de E/S.

Nos bastidores, o construtor ThreadPoolExecutor é chamado com os seguintes argumentos:

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
      new SynchronousQueue<Runnable>());
}

Os seguintes valores são passados ​​para o construtor como argumentos:

E podemos passar nossa própria implementação de ThreadFactory exatamente da mesma maneira.

Vamos falar sobre SynchronousQueue

A ideia básica de uma transferência síncrona é bastante simples e, no entanto, contra-intuitiva (ou seja, a intuição ou o bom senso dizem que está errado): você pode adicionar um elemento a uma fila se e somente se outro thread receber o elemento no mesmo tempo. Em outras palavras, uma fila síncrona não pode conter tarefas, pois assim que uma nova tarefa chega, a thread em execução já a pegou .

Quando uma nova tarefa entra na fila, se houver um thread ativo livre no pool, ela seleciona a tarefa. Se todos os threads estiverem ocupados, um novo thread será criado.

Um pool em cache começa com zero threads e pode aumentar potencialmente para Integer.MAX_VALUE threads. Essencialmente, o tamanho de um conjunto de encadeamentos em cache é limitado apenas pelos recursos do sistema.

Para conservar os recursos do sistema, os pools de encadeamentos em cache removem os encadeamentos que estão ociosos por um minuto.

Vamos ver como funciona na prática. Criaremos uma classe de tarefa que modela uma solicitação do usuário:

public class Task implements Runnable {
   int taskNumber;

   public Task(int taskNumber) {
       this.taskNumber = taskNumber;
   }

   @Override
   public void run() {
       System.out.println("Processed user request #" + taskNumber + " on thread " + Thread.currentThread().getName());
   }
}

No método main , criamos newCachedThreadPool e adicionamos 3 tarefas para execução. Aqui imprimimos o status do nosso serviço (1) .

Em seguida, pausamos por 30 segundos, iniciamos outra tarefa e exibimos o status (2) .

Depois disso, pausamos nosso thread principal por 70 segundos, imprimimos o status (3) , adicionamos novamente 3 tarefas e imprimimos novamente o status (4) .

Em locais onde exibimos o status imediatamente após adicionar uma tarefa, primeiro adicionamos uma suspensão de 1 segundo para saída atualizada.

ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 3; i++) {
            executorService.submit(new Task(i));
        }

        TimeUnit.SECONDS.sleep(1);
            System.out.println(executorService);	//(1)

        TimeUnit.SECONDS.sleep(30);

        executorService.submit(new Task(3));
        TimeUnit.SECONDS.sleep(1);
            System.out.println(executorService);	//(2)

        TimeUnit.SECONDS.sleep(70);

            System.out.println(executorService);	//(3)

        for (int i = 4; i < 7; i++) {
            executorService.submit(new Task(i));
        }

        TimeUnit.SECONDS.sleep(1);
            System.out.println(executorService);	//(4)
        executorService.shutdown();

E aqui está o resultado:

Vamos a cada uma das etapas:

Bem, agora você está familiarizado com a lógica de outro tipo de serviço executor.

Por analogia com outros métodos da classe utilitária Executors , o método newCachedThreadPool também possui uma versão sobrecarregada que recebe um objeto ThreadFactory como argumento.