Eine kurze Diskussion über Dienstausnahmen, die durch asynchrone Multithread-Zeitüberschreitungen in Java verursacht werden

Um die Leistungsstabilität großer Parallelität in Projekten zu verbessern, werden häufig Thread-Pools verwendet, um asynchrone Multithread-Vorgänge auszuführen. Eine davon besteht darin, die ausführbare Schnittstelle zu implementieren Der andere besteht darin, die ausführbare Schnittstelle zu implementieren. Die erste besteht darin, die aufrufbare Schnittstelle zu implementieren, die einen Rückgabewert hat.

Wenn bei einem der Threads eine Zeitüberschreitung auftritt, sollte dies theoretisch keinen Einfluss auf die Ausführungsergebnisse anderer Threads haben. Im Projekt aufgetretene Probleme zeigten jedoch, dass ein Thread blockiert war und die von anderen Threads zurückgegebenen Schnittstellen leer waren. Es ist eigentlich eine sehr einfache Frage, aber da es das erste Mal war, dass ich darauf stieß, habe ich noch einige Zeit darüber nachgedacht. Das ist ganz einfach, denn der blockierte Thread-

-Prozess wurde nicht freigegeben. Wenn die Parallelität groß ist, ist die Anzahl der Thread-Pools voll, sodass sich andere Threads im Wartezustand befinden.

Anbei ist ein Debugging-Code, den ich geschrieben habe. Wenn ich das Problem nicht herausfinden kann, kann ich es simulieren und selbst schreiben.

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();
    } 
}

Das Obige ist der vollständige Inhalt der kurzen Diskussion des Herausgebers über Dienstausnahmen, die durch asynchrone Multi-Thread-Timeouts in Java verursacht werden. Ich hoffe, dass jeder die chinesische PHP-Website unterstützt~

Mehr Eine kurze Diskussion zu Dienstausnahmen, die durch asynchrone Multi-Thread-Zeitüberschreitungen in Java verursacht werden. Weitere Artikel finden Sie auf der chinesischen PHP-Website.