Como implementar a interface chamável em Java



Este artigo fornecerá um conhecimento detalhado e abrangente de como implementar a Callable Interface em Java com exemplos.

Os programas Java multithreading testemunham o uso de extensas Chamável e futuro. Com o conhecimento prévio de threads e multithreading, os leitores serão capazes de compreender melhor a discussão neste artigo. Como estarei explicando a Callable Interface em Java neste artigo.

como encontrar o maior número em um array java

Recapitulação de tópicos

No entanto, deixe-me dar uma breve introdução ao conceito de threads. Um thread é um caminho separado de execução, caso seja necessário realizar uma tarefa repetitiva, o trabalho pode ser dividido em várias tarefas e atribuídas a threads. Multi-threadingnada mais é do que atribuir vários threads para executar tarefas diferentes em paralelo para obter o resultado rapidamente.





O que é Callable Interface em Java

Para Java 5, a classe “java.util.concurrent” foi introduzida. Essa interface chamável foi trazida por meio do pacote de simultaneidade que parecia semelhante à interface Runnable. Ele também pode retornar qualquer objeto e lançar uma exceção. Uma interface Java Callable utiliza Genéricos, possibilitando o retorno de qualquer tipo de objeto. O Executor Framework fornece um método submit () para executar implementações Callable em um pool de threads. Na realidade, o Java Executor Framework segue os padrões WorkerThread.

java-interfaceEm um pool de threads, os usuários podem iniciar threads usando o método Executors.newFixedThreadPool (10) e, portanto, enviar uma tarefa a ele. Um executável atua como o destino de uma thread e um método void run () público é implementado obrigatoriamente para definir a tarefa. Isso será executado por threads no pool de threads. Com base na disponibilidade dos threads no pool, o Executor Framework atribui trabalho (destino executável) aos threads.Se todos os threads estiverem em uso, a tarefa deve ser paralisada. Depois que o encadeamento conclui uma tarefa, ele retorna ao pool como um encadeamento disponível, que está pronto para aceitar tarefas futuras. Callable é semelhante a Runnable e pode retornar qualquer tipo de objeto quando queremos obter um resultado ou status da tarefa.



Retorno da interface chamável

Java Callable retorna java.util.concurrent. Java Future oferece um método cancel () para eliminar a tarefa Callable associada. Esta é uma versão sobrecarregada do método get (), onde se pode especificar um certo tempo de espera pelo resultado. É útil evitar um segmento atual, que pode ser bloqueado por um período mais longo. Lembre-se de que o método get é um método síncrono e até que o chamável termine sua tarefa e retorne um valor, ele terá que esperar por um chamável.

Existem também métodos “isDone ()” e “isCancelled ()” para obter o status atual de uma tarefa Callable associada. Considere o exemplo em que uma soma de todos os números de um a 100 precisa ser encontrada. Podemos fazer um loop de 1 a 100 sequencialmente e finalmente adicioná-los. Outra possibilidade é dividir e conquistar. Nesse método, podemos agrupar os números de forma que cada grupo tenha exatamente dois elementos. Finalmente, podemos atribuir esse grupo a um pool de threads. Portanto, cada thread retorna uma soma parcial em paralelo e, em seguida, coleta essas somas parciais e as adiciona para obter a soma total.



Características da classe Callable e Future

  • A classe chamável é uma interface do tipo SAM e, portanto, pode ser implementada na expressão lambda.

  • A classe que pode ser chamada tem apenas um método “call ()” que contém todo o código necessário para executar de forma assíncrona.

  • Em um ambiente de interface executável, não havia possibilidade de retornar o resultado do cálculo ou lançar exceção verificada. Enquanto Callable retornar um valor e lançar uma exceção verificada está disponível.

  • O método Get () da classe Future pode ser usado para recuperar resultados assim que o cálculo for concluído. Os usuários também podem verificar se o cálculo foi concluído ou não usando o método done ().

  • Cancelar o cálculo usando o método future.cancel () também é uma bênção em alguns aplicativos.

  • Get () é chamado de chamada de bloqueio e continua a bloquear até que o cálculo seja concluído.

    como usar um iterador em java

Comparação de classes chamáveis ​​e executáveis

Callable Executável
É parte do “ java.util.concurrent ' pacote desde Java 1.5Faz parte do pacote java.lang desde Java 1.0
Uma interface parametrizada, como CallableUma interface não parametrizada
Capaz de lançar uma exceção marcadaNão pode lançar uma exceção verificada
Ele contém um único método, call (), que retorna o Tipo V, que é o mesmo que o parâmetro de interface definido “Tipo”Aqui, ele contém um único método, chamado run (), que retorna void

Abaixo está um exemplo simples de uma classe Java chamável implementada em que o código retorna o nome do encadeamento específico, que está executando a tarefa após um segundo. Aqui, utilizamos a estrutura do extrator para executar 100 tarefas em paralelo com o Java Future para o resultado das tarefas enviadas. O primeiro snippet é a saída e o abaixo representa o código.

pacote com.journaldev.threads import java.util.ArrayList import java.util.Date import java.util.List import java.util.concurrent.Callable import java.util.concurrent.ExecutionException import java.util.concurrent.ExecutorService import java .util.concurrent.Executors import java.util.concurrent.Future public class MyCallable implementa Callable {@Override public String call () throws Exception {Thread.sleep (1000) // retorna o nome do thread executando esta tarefa chamável return Thread.currentThread () .getName ()} public static void main (String args []) {// Obter ExecutorService da classe de utilitário Executors, tamanho do pool de threads é 10 ExecutorService executor = Executors.newFixedThreadPool (10) // cria uma lista para conter o Future objeto associado à lista chamávellist = new ArrayList() // Criar instância MyCallable Callable callable = new MyCallable () para (int i = 0 i<100 i++){ //submit Callable tasks to be executed by thread pool Future future = executor.submit(callable) //add Future to the list, we can get return value using Future list.add(future) } for(Future fut : list){ try { //print the return value of Future, notice the output delay in console // because Future.get() waits for task to get completed System.out.println(new Date()+ '::'+fut.get()) } catch (InterruptedException | ExecutionException e) { e.printStackTrace() } } //shut down the executor service now executor.shutdown() } } 

Encerrando Serviços de Executor

O aspecto crucial e importante que muitos desenvolvedores perdem é o encerramento do ExecutorService. O ExecutorService é vital e é criado com elementos de thread adicionais. Lembre-se de que a JVM para apenas quando todos os encadeamentos não daemon são interrompidos. Assim, simplesmente desligar o serviço do executor evita que a JVM pare.

Para informar ao serviço do executor que não há necessidade de que os threads sejam executados, devemos encerrar o serviço.

Existem três maneiras de invocar o desligamento:

  • void shutdown () - Isso inicia um desligamento ordenado no qual as tarefas enviadas anteriormente são executadas, mas nenhuma tarefa nova é aceita.
  • List shutdownNow () - Ele tenta parar todas as tarefas em execução ativa, interrompe o processamento de tarefas pendentes e também retorna uma lista das tarefas que estavam aguardando execução.
  • void awaitTermination () - Isso continua a bloquear até que todas as tarefas tenham concluído a execução após uma solicitação de desligamento ou o tempo limite ocorra. Ele também bloqueia quando o thread atual é interrompido. Tudo depende de qual tarefa vem primeiro.

Com isso, chegamos ao fim do artigo Callable Interface in Java. Espero que você tenha entendido a interface Future and Callable Interface em Java.

Confira o pela Edureka, uma empresa de aprendizagem online confiável com uma rede de mais de 250.000 alunos satisfeitos espalhados por todo o mundo. O curso de certificação e treinamento Java J2EE e SOA da Edureka é projetado para estudantes e profissionais que desejam ser um desenvolvedor Java.

método de classificação c ++

Tem alguma questão para nós? Mencione isso na seção de comentários deste blog “Callable Interface in Java” e entraremos em contato com você o mais breve possível.