Interfaces appelables et futures
Calable est une interface similaire à Runnable.
Il existe plusieurs différences entre appelable et runnable:
(1) La méthode spécifiée par callable est Call (), tandis que la méthode spécifiée par Runnable est exécutée ().
(2) La tâche callable peut renvoyer la valeur après son exécution, tandis que la tâche exécutable ne peut pas renvoyer la valeur.
(3) La méthode Call () peut lancer des exceptions, tandis que la méthode Run () ne peut pas lancer des exceptions.
(4) Exécutez la tâche appelable et vous pouvez obtenir un futur objet.
Il fournit une méthode pour vérifier si le calcul est terminé, pour attendre que le calcul soit terminé et pour récupérer les résultats du calcul.
Grâce à l'objet futur, vous pouvez comprendre l'état d'exécution des tâches, annuler l'exécution de la tâche et également obtenir les résultats de l'exécution de la tâche.
La copie de code est la suivante:
Package com.yao;
import java.util.concurrent.Callable;
Importer java.util.concurrent.executorService;
Importer java.util.concurrent.executors;
import java.util.concurrent.future;
classe publique CalleableAndfuture {
/ **
* Personnalisez une classe de tâches pour implémenter l'interface appelée
* /
classe statique publique MyCallableClass implémente callable {
// Position du logo
INT PRIVATE FLAG = 0;
public myCallableClass (int flag) {
this.flag = drapeau;
}
Call de chaîne publique () lève l'exception {
if (this.flag == 0) {
// Si la valeur de l'indicateur est 0, retournez immédiatement
return "flag = 0";
}
if (this.flag == 1) {
// Si la valeur de l'indicateur est 1, faites une boucle infinie
essayer {
while (true) {
System.out.println ("Looping ...");
Thread.Sleep (2000);
}
} catch (InterruptedException e) {
System.out.println ("interrompu");
}
retourner "false";
} autre {
// Si le faux n'est pas 0 ou 1, une exception sera jetée
Jetez une nouvelle exception ("Bad Flag Value!");
}
}
}
public static void main (String [] args) {
// définir 3 tâches de types appelés
MyCallableClass Task1 = new myCallableClass (0);
MyCallableClass Task2 = new myCallableClass (1);
MyCallableClass Task3 = new myCallableClass (2);
// Créer un service qui effectue des tâches
ExecutorService es = exécutors.newFixEdThreadPool (3);
essayer {
// Soumettre et exécuter la tâche.
// Si vous souhaitez obtenir le résultat de l'exécution de la tâche ou de l'exception, vous pouvez opérer sur ce futur objet
Future Future1 = ES.SUMMIT (TASSE1);
// Obtenez le résultat de la première tâche.
System.out.println ("Task1:" + futur1.get ());
Future Future2 = ES.SUMMIT (TASK2);
// attendez 5 secondes avant d'arrêter la deuxième tâche. Parce que la deuxième tâche est une boucle infinie
Thread.Sleep (5000);
System.out.println ("Task2 Annuler:" + futur2.cancel (true));
// obtient la sortie de la troisième tâche, car l'exécution de la troisième tâche entraînera une exception
// donc l'énoncé suivant entraînera l'exception
Future Future3 = ES.SUMMIT (TASSE3);
System.out.println ("Task3:" + futur3.get ());
} catch (exception e) {
System.out.println (e.toString ());
}
// Arrête le service d'exécution de la tâche
es.shutdownNow ();
}
}