O que é ExecutorService em Java e como criá-lo?

A linguagem de programação Java funciona de forma muito eficiente com aplicativos que requerem que as tarefas sejam executadas simultaneamente em um thread. Torna-se difícil para qualquer aplicativo executar um grande número de threads simultaneamente. Então, para superar esse problema, vem com ExecutorService, que é uma subinterface do . Neste artigo, discutiremos a funcionalidade do ExecutorService em Java. A seguir estão os tópicos abordados neste blog:

• O que é Executor Framework?
• ExecutorService no exemplo de Java
• Implementações Java ExecutorService
  • ThreadPoolExecutor
  • ScheduledThreadPoolExecutor
• Uso do ExecutorService
• Executável vs Callable
• Desligamento do ExecutorService

O que é Executor Framework?

É bastante mais fácil criar e executar uma ou duas threads simultaneamente. Mas se torna difícil quando o número de threads aumenta para um número significativo. Aplicativos grandes com vários threads terão centenas de threads em execução simultaneamente. Portanto, faz todo o sentido separar a criação do encadeamento do gerenciamento do encadeamento em um aplicativo.

O executor é um ajuda você a criar e gerenciar threads em um aplicativo. o ajuda você nas seguintes tarefas.

• Criação de threads: fornece uma variedade de métodos para a criação de threads que ajudam a executar seus aplicativos simultaneamente.

  
  
  

• Gerenciamento de Thread: Também gerencia o ciclo de vida do thread. Você não precisa se preocupar se o thread está ativo, ocupado ou morto antes de enviar a tarefa para execução.

• Envio e execução de tarefas: a estrutura do Executor fornece métodos para o envio de tarefas no pool de threads. Também dá o poder de decidir se a thread será executada ou não.

ExecutorService no exemplo de Java

É uma subinterface do framework do executor que adiciona certas funcionalidades para gerenciar o ciclo de vida da thread de uma aplicação. Ele também fornece um método submit () que pode aceitar tanto executável quanto chamável objetos.

No exemplo a seguir, criaremos um ExecutorService com um único thread e, em seguida, enviaremos a tarefa a ser executada dentro do thread.

import java.util.concurrent.ExecutorService import java.util.concurrent.Executors public class Exemplo {public static void main (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( )) System.out.println ('criando ExecutorService') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('criando um runnable') Runnable runnable = () -> {System.out.println ('dentro de: '+ Thread.currentThread (). GetName ())} System.out.println (' enviar a tarefa especificada pelo executável para o executorservice ') executorservice.submit (runnable)}}

 Resultado: Inside: main criando ExecutorService criando um runnable enviar a tarefa especificada pelo runnable para o executorservice dentro de: pool-1-thread-1

O de cima mostra como podemos criar um ExecutorService e executar uma tarefa dentro do executor. Se uma tarefa for enviada para execução e o thread estiver ocupado executando outra tarefa, a tarefa aguardará em uma fila até que o thread esteja livre para executá-la.

Quando você executa o programa acima, ele nunca será encerrado. Você precisará encerrá-lo explicitamente, pois o serviço do executor continua ouvindo novas tarefas.

Implementações Java ExecutorService

ExecutorService é muito semelhante a um pool de threads. Na verdade, a implementação do ExecutorService no java.util.concurrent pacote é uma implementação de threadpool. O ExecutorService tem as seguintes implementações no pacote java.util.concurrent:

ThreadPoolExecutor

O ThreadPoolExecutor executa as tarefas fornecidas usando um de seus threads agrupados internamente.

Criando um threadPoolExecutor

int corePoolSize = 5 int maxPoolSize = 10 long keepAliveTime = 5000 ExecutorService threadPoolExecutor = new threadPoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, novo LinkedBlockingQueue ())

ScheduledThreadPoolExecutor

O java.util.concurrent.ScheduledThreadPoolExecutor é um ExecutorService que pode agendar tarefas para execução após um atraso ou para execução repetida com um intervalo fixo de tempo entre cada execução.

Exemplo

ScheduledExecutorService ScheduledExecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture Scheduledfuture = ScheduledExecutorService.schedule (new Callable () {public Object call () lança Exceção {System.out.println ('executado') return 'chamado'}}, 5, TimeUnit. SEGUNDOS)

Uso do ExecutorService

Existem algumas maneiras diferentes de delegar tarefas a um ExecutorService.

• executar (executável)

• enviar (executável)

• invokeAny ()

• invokeAll ()

Executar executável

Java ExecutorService execute (Runnable) pega um objeto java.lang.Runnable e o executa de forma assíncrona.

ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (new Runnable () {public void run () {System.out.println ('tarefa assíncrona')}}) executorService.shutdown ()

Não há como obter o resultado da execução do Runnable, para isso é necessário usar o Callable.

Enviar executável

O método Java ExecutorService submit (Runnable) usa uma implementação Runnable e retorna um objeto futuro. O objeto futuro pode ser usado para verificar se o Runnable terminou de ser executado.

Futuro futuro = executorService.submit (new Runnable () {public void run () {System.out.println (: tarefa assíncrona ')}}) future.get () // retorna nulo se a tarefa for concluída corretamente.

Enviar chamável

O método Java ExecutorService submit (Callable) é semelhante ao submit (Runnable), mas leva Java Callable em vez de Runnable.

Futuro futuro = executorService.submit (new Callable () {public Object call () lança Exceção {System.out.println ('Asynchronous callable') return 'Callable Result'}}) System.out.println ('future.get ( ) = 'future.get ())

 Resultado: Futuro solicitável assíncrono.get = Resultado solicitável

invokeAny ()

O método invokeAny () pega uma coleção de objetos Callable. Invocar este método não retorna nenhum futuro, mas retorna o resultado de um dos objetos Callable.

ExecutorService executorService = Executors.newSingleThreadExecutor () Definircallables = new HashSet() callables.add (new Callable () {public String call () lança Exceção {return'task A '}}) callables.add (new Callable () {public String call () throws Exception {return'task B'} }) callables.add (new Callable () {public String call () throws Exception {return'task C '}}) String result = executorService.invokeAny (callables) System.out.println (' result = '+ result) executorService .desligar()

Quando você executa o código acima, o resultado muda. Pode ser Tarefa A, Tarefa B e assim por diante.

InvokeAll ()

O método invokeAll () invoca todos os objetos Callable passados ​​como parâmetros. Ele retorna os objetos futuros que podem ser usados ​​para obter os resultados da execução de cada Callable.

ExecutorService executorService = Executors.newSingleThreadExecutor () Definircallables = new HashSet() callables.add (new Callable () {public String call () throws Exception {return 'Task A'}}) callables.add (new Callable () {public String call () throws Exception {return 'Task B'} }) callables.add (new Callable () {public String call () throws Exception {return 'Task C'}}) Listfutures = executorService.invokeAll (cobráveis) para (Futuro futuro: futuros) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()

Executável vs Callable

As interfaces executáveis ​​e chamáveis ​​são muito semelhantes entre si. A diferença é visível na declaração do interfaces. Ambas as interfaces representam uma tarefa que pode ser executada simultaneamente por um thread ou ExecutorService.

Declaração exigível:

interface pública Callable {public object call () throws Exception}

Declaração executável:

interface pública Executável {public void run ()}

A principal diferença entre os dois é que o método call () pode retornar um objeto da chamada do método. E o método call () pode lançar um enquanto o método run () não pode.

como implementar um hashmap

cancelar tarefa

Você pode cancelar a tarefa enviada ao ExecutorService simplesmente chamando o método cancel no futuro enviado quando a tarefa for enviada.

future.cancel ()

Desligamento do ExecutorService

Para evitar que os threads sejam executados mesmo após a conclusão da execução, você deve encerrar o ExecutorService.

desligar()

Para encerrar as threads dentro de um ExecutorService, você pode chamar o método shutdown ().

executorService.shutdown ()

Isso nos leva ao final deste artigo, onde aprendemos como podemos usar ExecutorService para executar tarefas em um thread. Espero que você tenha esclarecido tudo o que foi compartilhado com você neste tutorial.

Se você achou este artigo sobre “ExecutorService em Java” relevante, verifique o uma empresa de aprendizagem online confiável com uma rede de mais de 250.000 alunos satisfeitos espalhados por todo o mundo.

Estamos aqui para ajudá-lo em cada etapa da sua jornada e criar um currículo que é projetado para estudantes e profissionais que desejam ser um desenvolvedor Java. O curso foi desenvolvido para lhe dar uma vantagem inicial na programação Java e treiná-lo para os conceitos básicos e avançados de Java, juntamente com vários gostar Hibernar E .

Se tiver alguma dúvida, fique à vontade para fazer todas as suas perguntas na seção de comentários de “ExecutorService em Java” e nossa equipe terá prazer em responder.