Interface java appelable et son utilisation

Qu’est-ce qu’une interface Java apicole? Cette interface est considérablement liée à la programmation simultanée. Quand on commence à travailler en Java, la classe de thread apparaît rapidement qui nous permet d’exécuter des tâches simultanées. Toutefois, vous avez des limitations, voyons un exemple:

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);}}

Nous venons de créer une tâche qui implémente l’interface exécutable. Nous pouvons en avoir pour créer un thread ou un fil qui l’exécute et vous imprime à l’écran la somme des 5 premiers termes après 1500 millisecondes (la boucle Itera 5 fois).

package com.arquitecturajava;public class PrincipalHilo {public static void main(String args) {Tarea t= new Tarea();Thread hilo= new Thread(t);hilo.start();}}

Le résultat que nous voyons apparaît par la console:

Javacallabthreads

Tout a fonctionné correctement. Le problème est que nous sommes obligés d’imprimer les données par la console. La méthode d’exécution de l’interface runnable ne renvoie rien.

Navette annulable Java

Interface Java appelable

La plupart des occasions dont nous avons besoin d’une tâche parallèle à exécuter, puis un résultat sera renvoyé. Comment peut-on le faire? . Java prévoit ces situations de l’interface appelable, voyons-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&lt;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;}}

Dans ce cas, nous trouvons quelque chose de très similaire mais nous utilisons l’interface appelable. Cette interface a la méthode d’appel qui est capable de nous renvoyer un résultat que la méthode d’exécution n’autorise pas.

RUN VOYAL PUBLIQUE ();

Call public ();

Nous venons de créer une classe qui a mis en œuvre une interface Java apaisante mise en œuvre. Il est temps de l’utiliser à partir d’une méthode 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();}}}

Dans ce cas, nous avons utilisé exécutorservice pour créer une piscine de fil avec un seul fil et envoyer la tâche Pour pisciner à l’aide de la méthode de soumission.

Object java apaisant<7037915328 "

Objet Java Calable

Lorsque nous invoquons le service, nous recevrons automatiquement une variable de type future qui recevra une valeur future à laquelle nous pouvons imprimer à l’aide de la méthode Get ().

Future java appelable Get

Le résultat sur la console est similaire, la seule différence est que nous utilisons un pool de threads.

JavacAllable

Nous avons reçu des données de retour d’une tâche qui fonctionne en parallèle

Autres éléments connexes: service exécutif Java et filetage, Java Wait Notifier et threads, promesse javascript et programmation asynchrone

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *