¿Que é unha interface Java Calable? Esta interface está ligada significativamente á programación concorrente. Cando un comeza a traballar en Java, a clase de fíos parece que nos permite executar tarefas concorrentes. Non obstante, ten algunhas limitacións, imos ver un 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 crear unha tarefa que implementa a interface executable. Podemos deles para crear un fío ou fío que o execute e imprime na pantalla a suma dos primeiros 5 termos despois de 1500 milisegundos (The Itera Loop 5 veces).
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 que aparece na consola:
Todo funcionou correctamente. O problema é que estamos obrigados a imprimir os datos da consola. O método de execución da interface executable non devolve nada.
interface de java de chamada
A maioría das ocasións necesitamos unha tarefa paralela para ser executada e entón será devolto un resultado. Como podemos facer isto? .. Java ofrece estas situacións da interface de chamada, imos a ver.
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 atopamos algo moi similar, pero usamos a interface de chamada. Esta interface ten o método de chamada que é capaz de devolvernos un resultado de que o método de execución non permite.
Execución do baleiro público ();
chamada pública ();
P>
Acabamos de crear unha clase que implementou a interface de Java Calable. É hora de usalo desde o 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 para crear unha piscina con un único fío e enviar a tarefa a piscina usando o método de envío.
Cando invocamos o servizo recibiremos automaticamente unha variable de tipo futuro que recibirá nun valor futuro ao que 10 que podemos imprimir usando o método GET ().
O resultado da consola é similar, a única diferenza é que usamos unha piscina de fíos.
Recibimos datos de retorno dunha tarefa que se executa en paralelo
Outros elementos relacionados: Java Executor Service e Threading, Java Wait Notificar e fíos, promesa JavaScript e programación asíncrona