Une brève discussion sur les exceptions de service provoquées par le délai d'attente multithread asynchrone en Java

Afin d'améliorer la stabilité des performances de la grande concurrence dans les projets, les pools de threads sont souvent utilisés pour effectuer des opérations asynchrones multi-threads, l'un consiste à implémenter l'interface exécutable, qui n'a aucun retour. et l'autre consiste à implémenter l'interface exécutable. La première consiste à implémenter l'interface Callable, qui a une valeur de retour.

Lorsqu'un des threads expire, cela ne devrait théoriquement pas affecter les résultats d'exécution des autres threads. Cependant, des problèmes survenus dans le projet ont montré qu'un thread était bloqué et que les interfaces renvoyées par d'autres threads étaient vides. C'est en fait une question très simple, mais comme c'était la première fois que je la rencontrais, j'y ai encore réfléchi pendant un certain temps. C'est très simple, car le processus de thread bloqué

n'a pas été libéré, et le degré de concurrence est important, le nombre de pools de threads est plein, donc les autres threads sont en attente.

Vous trouverez ci-joint un morceau de code de débogage que j'ai écrit. Lorsque je n'arrive pas à comprendre le problème, je peux le simuler et l'écrire moi-même.

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
 
public class FutureTest
{
 
  public static void main(String[] args) throws InterruptedException,
    ExecutionException, TimeoutException
  {
 
    final ExecutorService exec = Executors.newFixedThreadPool(1);
     
 
    Callable<String> call = new Callable<String>() {
      public String call() throws InterruptedException
      {
        // 开始执行耗时操作
          Thread.sleep(1000 * 2); 
        return "1线程执行完成.";
      }
    };
 
    Callable<String> call2 = new Callable<String>() {
      public String call() throws Exception
      {
        // 开始执行耗时操作
        // Thread.sleep(1000 * 5);
        return "2线程执行完成.";
      }
    };
     
    Callable<String> call3 = new Callable<String>() {
      public String call() throws Exception
      {
        // 开始执行耗时操作
        // Thread.sleep(1000 * 5);
        return "3线程执行完成.";
      }
    };
 
    Future<String> future = exec.submit(call);
    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); // 任务处理超时时间设为
      }// 1 秒
      catch(Exception e){
        System.out.println("处理超时啦....");
        e.printStackTrace();
      }
       
      try{
        obj3 = future3.get(3000, TimeUnit.MILLISECONDS); // 任务处理超时时间设为
        }// 1 秒
        catch(Exception e){
          System.out.println("处理超时啦....");
          e.printStackTrace();
        }
       
      try{
       obj2 = future2.get(3000, TimeUnit.MILLISECONDS);}
      catch(Exception e){
        System.out.println("处理超时啦....");
        e.printStackTrace();
      }
      System.out.println("3任务成功返回:" + obj3);
      System.out.println("2任务成功返回:" + obj2);
      System.out.println("1任务成功返回:" + obj);
      exec.shutdown();
    } 
}

Ce qui précède est la brève discussion apportée par l'éditeur sur les exceptions de service causées par le délai d'attente multithread asynchrone en Java. J'espère que tout le monde soutiendra le site Web PHP chinois ~

Plus A. brève discussion sur les exceptions de service causées par le délai d'attente multithread asynchrone en Java Pour les articles connexes, veuillez faire attention au site Web PHP chinois !