Callable und zukünftige Schnittstellen
Callable ist eine Schnittstelle wie Runnable.
Es gibt verschiedene Unterschiede zwischen Callable und Runnable:
(1) Die durch Callable angegebene Methode ist CALL (), während die durch Runnable angegebene Methode ausgeführt wird ().
(2) Die aufrufbare Aufgabe kann den Wert nach seiner Ausführung zurückgeben, während die Runnable -Aufgabe den Wert nicht zurückgeben kann.
(3) Die CALL () -Methode kann Ausnahmen veröffentlichen, während die Run () -Methode keine Ausnahmen auslösen kann.
(4) Führen Sie die Callable -Aufgabe aus und Sie können ein zukünftiges Objekt erhalten.
Es bietet eine Methode, um zu prüfen, ob die Berechnung abgeschlossen ist, um die Berechnung abzuschließen und die Ergebnisse der Berechnung abzurufen.
Über das zukünftige Objekt können Sie den Status der Aufgabenausführung verstehen, die Aufgabenausführung absagen und die Ergebnisse der Aufgabenausführung erhalten.
Die Codekopie lautet wie folgt:
Paket com.yao;
import Java.util.concurrent.callable;
import Java.util.concurrent.executorService;
import Java.util.concurrent.executors;
import Java.util.concurrent.future;
öffentliche Klassen CallableAndfuture {
/**
* Passen Sie eine Aufgabenklasse an, um die Callable -Schnittstelle zu implementieren
*/
öffentliche statische Klasse mycallableClass implementiert Callable {
// Logo -Position
private int flag = 0;
public mycallableClass (int flag) {
this.flag = Flag;
}
public String call () löst Ausnahme {aus {
if (this.flag == 0) {
// Wenn der Wert der Flagge 0 ist, kehren Sie sofort zurück
zurück "flag = 0";
}
if (this.flag == 1) {
// Wenn der Wert der Flag 1 ist, machen Sie eine unendliche Schleife
versuchen {
while (wahr) {
System.out.println ("Looping ...");
Thread.Sleep (2000);
}
} catch (InterruptedException e) {
System.out.println ("unterbrochen");
}
zurück "false";
} anders {
// Wenn das Falsch nicht 0 oder 1 ist, wird eine Ausnahme geworfen
Neue Ausnahme ("schlechter Flaggenwert!");
}
}
}
public static void main (String [] args) {
// 3 Aufgaben auf Callable -Typen definieren
MyCallableClass Task1 = New MyCallableClass (0);
MyCallableClass Task2 = New MyCallableClass (1);
MyCallableClass Task3 = New MyCallableClass (2);
// Erstellen Sie einen Dienst, der Aufgaben ausführt
ExecutorService ES = Executors.NewFixedThreadpool (3);
versuchen {
// die Aufgabe einreichen und ausführen.
// Wenn Sie das Ergebnis von Aufgabenausführung oder Ausnahme erzielen möchten, können Sie dieses zukünftige Objekt arbeiten
Future Future1 = ES.Submit (Task1);
// Erhalten Sie das Ergebnis der ersten Aufgabe.
System.out.println ("Task1:" + Future1.get ());
Future Future2 = ES.Submit (Aufgabe2);
// Warten Sie 5 Sekunden, bevor Sie die zweite Aufgabe stoppen. Weil die zweite Aufgabe eine unendliche Schleife ist
Thread.sleep (5000);
System.out.println ("Task2 Cancel:" + Future2.Cancel (true));
// Erhalten Sie die Ausgabe der dritten Aufgabe, da die Ausführung der dritten Aufgabe eine Ausnahme hervorruft
// Die folgende Aussage wird also dazu führen, dass die Ausnahme geworfen wird
Future Future3 = ES.Submit (Aufgabe3);
System.out.println ("Task3:" + Future3.get ());
} catch (Ausnahme e) {
System.out.println (e.toString ());
}
// den Aufgabenausführungsdienst stoppen
es.shutdownnow ();
}
}