ExecutorService interface

Por que você precisa da interface do Executor?

Antes do Java 5, você tinha que escrever todo o seu próprio gerenciamento de encadeamento de código em seu aplicativo. Além disso, criar umnovo tópicoO objeto é uma operação com uso intensivo de recursos e não faz sentido criar um novo thread para cada tarefa leve. E como esse problema é familiar para absolutamente todos os desenvolvedores de aplicativos multiencadeados, eles decidiram trazer essa funcionalidade para o Java como a estrutura Executor .

Qual é a grande idéia? É simples: ao invés de criar uma nova thread para cada nova tarefa, as threads são mantidas em uma espécie de "armazenamento", e quando chega uma nova tarefa, recuperamos uma thread existente ao invés de criar uma nova.

As principais interfaces dessa estrutura são Executor , ExecutorService e ScheduledExecutorService , cada uma das quais estende a funcionalidade da anterior.

A interface Executor é a interface base. Ele declara um único método void execute(Runnable command) que é implementado por um objeto Runnable .

A interface ExecutorService é mais interessante. Possui métodos para gerenciar a conclusão do trabalho, bem como métodos para retornar algum tipo de resultado. Vamos dar uma olhada em seus métodos:

Vejamos um pequeno exemplo de trabalho com ExecutorService .

import java.util.List;
import java.util.concurrent.*;

public class ExecutorServiceTest {
   public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
//Create an ExecutorService for 2 threads
       java.util.concurrent.ExecutorService executorService = new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10));
// Create 5 tasks
       MyRunnable task1 = new MyRunnable();
       MyRunnable task2 = new MyRunnable();
       MyRunnable task3 = new MyRunnable();
       MyRunnable task4 = new MyRunnable();
       MyRunnable task5 = new MyRunnable();

       final List<MyRunnable> tasks = List.of(task1, task2, task3, task4, task5);
// Pass a list that contains the 5 tasks we created
       final List<Future<Void>> futures = executorService.invokeAll(tasks, 6, TimeUnit.SECONDS);
       System.out.println("Futures received");

// Stop the ExecutorService
       executorService.shutdown();

       try {
           TimeUnit.SECONDS.sleep(3);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println(executorService.isShutdown());
       System.out.println(executorService.isTerminated());
   }

   public static class MyRunnable implements Callable<Void> {

       @Override
       public void call() {
// Add 2 delays. When the ExecutorService is stopped, we will see which delay is in progress when the attempt is made to stop execution of the task
           try {
               TimeUnit.SECONDS.sleep(3);
           } catch (InterruptedException e) {
               System.out.println("sleep 1: " + e.getMessage());
           }
           try {
               TimeUnit.SECONDS.sleep(2);
           } catch (InterruptedException e) {
               System.out.println("sleep 2: " + e.getMessage());
           }
           System.out.println("done");
           return null;
       }
   }
}

Saída:

Cada tarefa é executada por 5 segundos. Criamos um pool para dois threads, então as duas primeiras linhas de saída fazem todo o sentido.

Seis segundos após o início do programa, o método invokeAll atinge o tempo limite e o resultado é retornado como uma lista de Futures . Isso pode ser visto na string de saída Futuros recebidos .

Depois que as duas primeiras tarefas são concluídas, outras duas começam. Mas como o tempo limite definido no método invokeAll expira, essas duas tarefas não têm tempo para serem concluídas. Eles recebem um comando "cancelar" . É por isso que a saída tem duas linhas com sono 1: sono interrompido .

E então você pode ver mais duas linhas com done . Este é o efeito colateral que mencionei ao descrever o método invokeAll .

A quinta e última tarefa nunca é iniciada, então não vemos nada sobre ela na saída.

As duas últimas linhas são o resultado da chamada dos métodos isShutdown e isTerminated .

Também é interessante executar este exemplo no modo de depuração e observar o status da tarefa após o tempo limite (defina um ponto de interrupção na linha com executorService.shutdown(); ):

Vemos que duas tarefas foram concluídas normalmente e três tarefas foram "canceladas" .

ScheduledExecutorService

Para concluir nossa discussão sobre executores, vamos dar uma olhada em ScheduledExecutorService .

Possui 4 métodos: