O que é uma interface java calável para? Essa interface está marcada significativamente a programação simultânea. Quando se começa a trabalhar no Java, a classe de thread parece rapidamente que nos permite executar tarefas simultâneas. No entanto, você tem algumas limitações, vamos ver um exemplo:
package com.arquitecturajava;public class Tarea implements Runnable {@Overridepublic void run() {int total = 0;for(int i=0;i<5;i++) {total+=i;try {Thread.sleep(300);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}System.out.println(Thread.currentThread().getName());System.out.println(total);}}
Acabamos de criar uma tarefa que implementa a interface runnable. Podemos com um thread ou thread que o executa e nos imprime na tela a soma dos primeiros 5 termos após 1500 milissegundos (o loop ITERA 5 vezes).
package com.arquitecturajava;public class PrincipalHilo {public static void main(String args) {Tarea t= new Tarea();Thread hilo= new Thread(t);hilo.start();}}
O resultado que vemos aparecer pelo console:
Tudo funcionou corretamente. O problema é que somos forçados a imprimir os dados pelo console. O método de execução da interface runnable não retorna nada.
interface java calável
A maioria das ocasiões precisamos de uma tarefa paralela a ser executada e, em seguida, um resultado será devolvido. Como podemos fazer isso? . Java fornece essas situações da interface calável, vamos vê-la.
package com.arquitecturajava;import java.util.concurrent.Callable;public class MiCallable implements Callable<Integer> {@Overridepublic Integer call() throws Exception {int total = 0;for(int i=0;i<5;i++) {total+=i;try {Thread.sleep(300);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}System.out.println(Thread.currentThread().getName());return total;}}
Neste caso, encontramos algo muito semelhante, mas usamos a interface calável. Esta interface tem o método de chamada que é capaz de retornar um resultado que o método de execução não permite.
Public Void Run ();
Public T Chamada ();
Acabamos de criar uma classe que implementou a interface java calável. É hora de usá-lo de um método principal.
package com.arquitecturajava;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class PrincipalCallable {public static void main(String args) {try {ExecutorService servicio= Executors.newFixedThreadPool(1);Future<Integer> resultado= servicio.submit(new MiCallable());if(resultado.isDone()) {System.out.println(resultado.get()); }} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (ExecutionException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}
Neste caso, usamos executores do executor para criar um pool de threads com um único thread e enviar a tarefa para a piscina usando o método de envio.
Quando invocamos o serviço, receberemos automaticamente uma variável de tipo futuro que receberá em um valor futuro para o qual 10 que possamos imprimir usando o método Get ().
O resultado no console é semelhante, a única diferença é que usamos um pool de segmentos.
Recebemos dados de retorno de uma tarefa que é executado em paralelo
Outros itens relacionados: Serviço de Execução Java e Threading, Java Wait Notificar e encadeamentos, promessa de JavaScript e programação assíncrona