Afin d'améliorer la stabilité des performances d'un grand volume de concurrence dans le projet, les pools de threads sont souvent utilisés pour effectuer des opérations asynchrones multi-thread. Il existe deux types de multi-threading. L'un consiste à implémenter l'interface Runnable, qui n'a pas de valeur de retour, et l'autre consiste à implémenter l'interface callable, qui a une valeur de retour.
Lorsque l'un des threads a expiré, il ne devrait pas théoriquement affecter les résultats d'exécution d'autres threads, mais les problèmes qui se posent dans le projet indiquent qu'un thread est bloqué et les interfaces renvoyées par les autres threads sont vides. En fait, c'est une question très simple, mais parce que je l'ai rencontré pour la première fois, j'y ai toujours réfléchi pendant un certain temps. C'est très simple, c'est à cause de la ligne de blocage
Le processus n'est pas libéré, et une fois le montant concurrentiel important, le nombre de pools de thread sera plein, donc les autres threads sont en attente.
Joints est un code de débogage que j'ai écrit moi-même. Quand je ne peux pas penser à un problème, je l'ai simulé et peut-être que le problème sortira.
import java.util.concurrent.callable; import java.util.concurrent.executionException; importer java.util.concurrent.executorvice; import java.util.concurrent.executors; import java.util.concurrent.future; import java.util.concurrent.timenit; import; java.util.concurrent.timeOutException; public class FutureTest {public static void main (String [] args) lève InterruptedException, ExecutionException, timeException {final ExecutorService exec = exécutor.newFixEdThreadPool (1); Callable <string> call = new Callable <string> () {public String Call () lève InterruptedException {// Commencez à exécuter l'opération qui prend du temps Thread.Sleep (1000 * 2); Renvoie "1 Thread Exécution terminée."; }}; Callable <string> call2 = new Callable <string> () {public String Call () lève une exception {// commencer à exécuter l'opération de temps qui prend du temps // Thread.Sleep (1000 * 5); RETOUR "2 L'exécution du thread est terminée."; }}; Callable <string> call3 = new Callable <string> () {public String Call () lève une exception {// commencer à exécuter l'opération de temps qui prend du temps // Thread.Sleep (1000 * 5); RETOUR "3 L'exécution du thread est terminée."; }}; Futur <string> futur = exec.submit (appel); Futur <string> future3 = exec.submit (call3); Futur <string> futur2 = exec.submit (call2); String obj = ""; String obj2 = ""; String obj3 = ""; essayez {obj = futur.get (500, timeunit.milliseconds); // Définissez le délai de traitement des tâches sur} // 1 seconde catch (exception e) {System.out.println ("Time Timeout ...."); e.printStackTrace (); } try {obj3 = future3.get (3000, timeunit.milliseconds); // Définit le délai de traitement des tâches sur} // 1 seconde catch (exception e) {System.out.println ("Time Timeout ......"); e.printStackTrace (); } try {obj2 = future2.get (3000, timeunit.milliseconds);} catch (exception e) {System.out.println ("Processing Timeout ...."); e.printStackTrace (); } System.out.println ("3 La tâche renvoie avec succès:" + obj3); System.out.println ("2 La tâche renvoie avec succès:" + Obj2); System.out.println ("1 tâche Renvoie avec succès:" + obj); exec.shutdown (); }}Ce qui précède est la brève discussion des exceptions de service causées par le délai d'asynchrone multi-lancement en Java. J'espère que tout le monde soutiendra Wulin.com plus ~