per cui è un’interfaccia Java classificabile? Questa interfaccia è collegata in modo significativo alla programmazione simultanea. Quando si inizia a lavorare in Java, viene visualizzata rapidamente la classe di discussione che ci consente di eseguire attività simultanee. Tuttavia, hai alcune limitazioni, vediamo un esempio:
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);}}
Abbiamo appena creato un compito che implementa l’interfaccia runnicabile. Possiamo da esso per creare un thread o un filo che lo esegue e stampaci sullo schermo la somma dei primi 5 termini dopo 1500 millisecondi (il loop itera 5 volte).
package com.arquitecturajava;public class PrincipalHilo {public static void main(String args) {Tarea t= new Tarea();Thread hilo= new Thread(t);hilo.start();}}
Il risultato che vediamo che appare dalla console:
Tutto ha funzionato correttamente. Il problema è che siamo costretti a stampare i dati dalla console. Il metodo di esecuzione dell’interfaccia runnicabile non restituisce nulla.
interfaccia java chiamante
La maggior parte delle occasioni abbiamo bisogno di un compito parallelo da eseguire e quindi verrà restituito un risultato. Come possiamo fare questo? . Java prevede queste situazioni dell’interfaccia chiamosa, vediamo.
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;}}
In questo caso troviamo qualcosa di molto simile ma usiamo l’interfaccia chiamante. Questa interfaccia ha il metodo di chiamata che è in grado di restituirci un risultato che il metodo di esecuzione non consente.
Public Void Run ();
Public T Chiama ();
Abbiamo appena creato una classe che ha implementato l’interfaccia Java calibile. È tempo di usarlo da un metodo principale.
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();}}}
In questo caso abbiamo utilizzato EXECTORService per creare un pool di filettatura con un solo thread e inviare l’attività per mettere in comune il metodo di invio.
Quando invochiamo il servizio riceveremo automaticamente una variabile di tipo futuro che riceverà in un valore futuro a cui 10 che possiamo stampare utilizzando il metodo GET ().
Il risultato sulla console è simile, l’unica differenza è che usiamo un pool di fili.
Abbiamo ricevuto dati di ritorno da un’attività che viene eseguita in parallelo
altri articoli correlati: Java Executor Service and Threading, Java Aspetta Notifica e fili, Promise JavaScript e programmazione asincrona