Um die Leistungsstabilität eines großen Parallelitätsvolumens im Projekt zu verbessern, werden Fadenpools häufig zur Durchführung von asynchronen Multi-Thread-Operationen verwendet. Es gibt zwei Arten von Multi-Threading. Einer besteht darin, die Runnable -Schnittstelle zu implementieren, die keinen Rückgabewert hat, und das andere ist die Implementierung der Callable -Schnittstelle, die einen Rückgabewert hat.
Wenn einer der Threads zeitlich abgestimmt ist, sollte er die Ausführungsergebnisse anderer Threads nicht theoretisch beeinflussen, aber die im Projekt auftretenden Probleme zeigen, dass ein Thread blockiert und die von den anderen Threads zurückgegebenen Schnittstellen leer sind. Eigentlich ist es eine sehr einfache Frage, aber weil ich sie zum ersten Mal begegnet habe, habe ich immer noch eine Weile darüber nachgedacht. Es ist sehr einfach, es liegt an der Blockierungslinie
Der Prozess wird nicht freigegeben, und sobald die Parallelitätsmenge groß ist, ist die Anzahl der Threadpools voll, sodass andere Threads in einem Wartezustand befinden.
Angehängt ist ein Debugging -Code, den ich selbst geschrieben habe. Wenn ich mir kein Problem vorstellen kann, habe ich es simuliert und vielleicht wird das Problem herauskommen.
importieren java.util.concurrent.callable; import java.util.concurrent java.util.concurrent.timeoutexception; public class futuretest {public static void main (String [] args) löst InterruptedException, ExecutionException, timeoutexception aus {endgültiger Executorservice exec = ausführende.newfixedThreadpool (1); CALLABLE <string> call = new Callable <string> () {public String call () löscht InterruptedException {// mit der Ausführung zeitaufwändiger Operation Thread.sleep (1000 * 2); Rückgabe "1 Thread Execution fertiggestellt."; }}; CALLABLE <string> CALL2 = NEU CALLABLE <string> () {public String call () löst Ausnahme aus {// Ausführen zeitaufwändiger Operation // Thread.sleep (1000 * 5); Rückgabe "2 Thread Execution ist abgeschlossen."; }}; CALLABLE <string> call3 = new Callable <string> () {public String call () löst eine Ausnahme aus {// Ausführen zeitaufwändiger Operation // Thread.sleep (1000 * 5); Rückgabe "3 Thread Execution ist abgeschlossen."; }}; Future <String> Future = exec.Submit (Anruf); Future <String> Future3 = exec.Submit (Call3); Future <String> Future2 = exec.Submit (Call2); String obj = ""; String obj2 = ""; String obj3 = ""; try {obj = future.get (500, TimeUnit.Milliseconds); // Setzen Sie die Aufgabenverarbeitung Timeout auf} // 1 Sekunde Catch (Ausnahme e) {System.out.println ("Timeout verarbeiten ...."); E. printstacktrace (); } try {obj3 = future3.get (3000, TimeUnit.Milliseconds); // Setzen Sie die Aufgabenverarbeitung Zeitüberschreitung auf} // 1 Sekunde Catch (Ausnahme e) {System.out.println ("Timeout verarbeiten ......"); E. printstacktrace (); } try {obj2 = future2.get (3000, TimeUnit.Milliseconds);} catch (Ausnahme e) {System.out.println ("Timeout verarbeiten ...."); E. printstacktrace (); } System.out.println ("3 Task gibt erfolgreich zurück:" + obj3); System.out.println ("2 Task gibt erfolgreich zurück:" + obj2); System.out.println ("1 Task gibt erfolgreich zurück:" + obj); exec.shutdown (); }}Das oben genannte ist die kurze Diskussion über Dienstausnahmen, die durch asynchrone Multi-Threading-Zeitüberschreitungen in Java verursacht werden. Ich hoffe, jeder wird Wulin.com mehr unterstützen ~