Java：在特定代码块上设置超时？

Question

是否有可能在某些代码块运行时间超过可接受的时间后强制 Java 抛出异常？

Answer 1

这是我所知道的最简单的方法：

final Runnable stuffToDo = new Thread() {
  @Override 
  public void run() { 
    /* Do stuff here. */ 
  }
};

final ExecutorService executor = Executors.newSingleThreadExecutor();
final Future future = executor.submit(stuffToDo);
executor.shutdown(); // This does not cancel the already-scheduled task.

try { 
  future.get(5, TimeUnit.MINUTES); 
}
catch (InterruptedException ie) { 
  /* Handle the interruption. Or ignore it. */ 
}
catch (ExecutionException ee) { 
  /* Handle the error. Or ignore it. */ 
}
catch (TimeoutException te) { 
  /* Handle the timeout. Or ignore it. */ 
}
if (!executor.isTerminated())
    executor.shutdownNow(); // If you want to stop the code that hasn't finished.

或者，您可以创建一个 TimeLimitedCodeBlock 类来包装此功能，然后您可以在任何需要的地方使用它，如下所示：

new TimeLimitedCodeBlock(5, TimeUnit.MINUTES) { @Override public void codeBlock() {
    // Do stuff here.
}}.run();

Answer 2

我将其他一些答案编译成一个实用方法：

public class TimeLimitedCodeBlock {

  public static void runWithTimeout(final Runnable runnable, long timeout, TimeUnit timeUnit) throws Exception {
    runWithTimeout(new Callable<Object>() {
      @Override
      public Object call() throws Exception {
        runnable.run();
        return null;
      }
    }, timeout, timeUnit);
  }

  public static <T> T runWithTimeout(Callable<T> callable, long timeout, TimeUnit timeUnit) throws Exception {
    final ExecutorService executor = Executors.newSingleThreadExecutor();
    final Future<T> future = executor.submit(callable);
    executor.shutdown(); // This does not cancel the already-scheduled task.
    try {
      return future.get(timeout, timeUnit);
    }
    catch (TimeoutException e) {
      //remove this if you do not want to cancel the job in progress
      //or set the argument to 'false' if you do not want to interrupt the thread
      future.cancel(true);
      throw e;
    }
    catch (ExecutionException e) {
      //unwrap the root cause
      Throwable t = e.getCause();
      if (t instanceof Error) {
        throw (Error) t;
      } else if (t instanceof Exception) {
        throw (Exception) t;
      } else {
        throw new IllegalStateException(t);
      }
    }
  }

}

使用此实用方法的示例代码：

  public static void main(String[] args) throws Exception {
    final long startTime = System.currentTimeMillis();
    log(startTime, "calling runWithTimeout!");
    try {
      TimeLimitedCodeBlock.runWithTimeout(new Runnable() {
        @Override
        public void run() {
          try {
            log(startTime, "starting sleep!");
            Thread.sleep(10000);
            log(startTime, "woke up!");
          }
          catch (InterruptedException e) {
            log(startTime, "was interrupted!");
          }
        }
      }, 5, TimeUnit.SECONDS);
    }
    catch (TimeoutException e) {
      log(startTime, "got timeout!");
    }
    log(startTime, "end of main method!");
  }

  private static void log(long startTime, String msg) {
    long elapsedSeconds = (System.currentTimeMillis() - startTime);
    System.out.format("%1$5sms [%2$16s] %3$s\n", elapsedSeconds, Thread.currentThread().getName(), msg);
  }

在我的计算机上运行示例代码的输出：

    0ms [            main] calling runWithTimeout!
   13ms [ pool-1-thread-1] starting sleep!
 5015ms [            main] got timeout!
 5016ms [            main] end of main method!
 5015ms [ pool-1-thread-1] was interrupted!

Answer 3

是的，但强制另一个线程中断随机代码行通常是一个非常糟糕的主意。仅当您打算关闭该进程时才需要执行此操作。

您可以做的是在一段时间后使用 Thread.interrupt() 来执行任务。但是，除非代码对此进行检查，否则它将无法工作。 ExecutorService 可以通过 Future.cancel(true) 使这一点变得更容易。

它可以更好地让代码自行计时并在需要时停止。

Answer 4

如果是测试代码你想计时，那么你可以使用time属性：

@Test(timeout = 1000)  
public void shouldTakeASecondOrLess()
{
}

如果是生产代码，没有简单的机制，你使用哪种解决方案取决于你是否可以改变代码是否定时。

如果您可以更改正在计时的代码，那么一个简单的方法是让您的计时代码记住它的开始时间，并定期记住当前时间。例如，

long startTime = System.currentTimeMillis();
// .. do stuff ..
long elapsed = System.currentTimeMillis()-startTime;
if (elapsed>timeout)
   throw new RuntimeException("tiomeout");

如果代码本身无法检查超时，您可以在另一个线程上执行代码，并等待完成或超时。

    Callable<ResultType> run = new Callable<ResultType>()
    {
        @Override
        public ResultType call() throws Exception
        {
            // your code to be timed
        }
    };

    RunnableFuture<ResultType> future = new FutureTask<>(run);
    ExecutorService service = Executors.newSingleThreadExecutor();
    service.execute(future);
    ResultType result = null;
    try
    {
        result = future.get(1, TimeUnit.SECONDS);    // wait 1 second
    }
    catch (TimeoutException ex)
    {
        // timed out. Try to stop the code if possible.
        future.cancel(true);
    }
    service.shutdown();
}

Answer 5

我可以建议两个选择。

1. 在该方法中，假设它正在循环并且不等待外部事件，请添加一个本地字段并测试每次循环的时间。

   void 方法() {
       长 endTimeMillis = System.currentTimeMillis() + 10000;
       而（真）{
           // 方法逻辑
           if (System.currentTimeMillis() > endTimeMillis) {
               // 做一些清理工作
               返回;
           }
       }
   }
   

2. 在线程中运行该方法，并让调用者数到 10 秒。

   Thread 线程 = new Thread(new Runnable() {
           @覆盖
           公共无效运行（）{
               方法（）;
           }
   });
   线程.start();
   长 endTimeMillis = System.currentTimeMillis() + 10000;
   while (thread.isAlive()) {
       if (System.currentTimeMillis() > endTimeMillis) {
           // 设置错误标志
           休息;
       }
       尝试 {
           线程.sleep(500);
       }
       catch (InterruptedException t) {}
   }
   

这种方法的缺点是 method() 不能直接返回值，它必须更新实例字段才能返回其值。

Answer 6

编辑：Peter Lawrey 是完全正确的：它并不像中断线程（我最初的建议）和 Executors & 那样简单。 Callable 非常有用......

一旦达到超时，您可以在 Callable 上设置一个变量，而不是中断线程。可调用程序应在任务执行的适当时刻检查此变量，以了解何时停止。

Callables 返回 Futures，当您尝试“获取”未来的结果时，您可以使用它指定超时。像这样的东西：

try {
   future.get(timeoutSeconds, TimeUnit.SECONDS)
} catch(InterruptedException e) {
   myCallable.setStopMeAtAppropriatePlace(true);
}

请参阅 Future.get、Executors 和 Callable ...

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Future.html#get-long-java.util.concurrent.TimeUnit-

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Callable.html

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool%28int%29

Answer 7

我创建了一个非常简单的解决方案，没有使用任何框架或 API。这看起来更优雅且更容易理解。该类称为 TimeoutBlock。

public class TimeoutBlock {

 private final long timeoutMilliSeconds;
    private long timeoutInteval=100;

    public TimeoutBlock(long timeoutMilliSeconds){
        this.timeoutMilliSeconds=timeoutMilliSeconds;
    }

    public void addBlock(Runnable runnable) throws Throwable{
        long collectIntervals=0;
        Thread timeoutWorker=new Thread(runnable);
        timeoutWorker.start();
        do{ 
            if(collectIntervals>=this.timeoutMilliSeconds){
                timeoutWorker.stop();
                throw new Exception("<<<<<<<<<<****>>>>>>>>>>> Timeout Block Execution Time Exceeded In "+timeoutMilliSeconds+" Milli Seconds. Thread Block Terminated.");
            }
            collectIntervals+=timeoutInteval;           
            Thread.sleep(timeoutInteval);

        }while(timeoutWorker.isAlive());
        System.out.println("<<<<<<<<<<####>>>>>>>>>>> Timeout Block Executed Within "+collectIntervals+" Milli Seconds.");
    }

    /**
     * @return the timeoutInteval
     */
    public long getTimeoutInteval() {
        return timeoutInteval;
    }

    /**
     * @param timeoutInteval the timeoutInteval to set
     */
    public void setTimeoutInteval(long timeoutInteval) {
        this.timeoutInteval = timeoutInteval;
    }
}

示例：

try {
        TimeoutBlock timeoutBlock = new TimeoutBlock(10 * 60 * 1000);//set timeout in milliseconds
        Runnable block=new Runnable() {

            @Override
            public void run() {
                //TO DO write block of code to execute
            }
        };

        timeoutBlock.addBlock(block);// execute the runnable block 

    } catch (Throwable e) {
        //catch the exception here . Which is block didn't execute within the time limit
    }

当我必须连接到 FTP 帐户时，这对我非常有用。然后下载并上传东西。有时 FTP 连接会挂起或完全中断。这导致整个系统瘫痪。我需要一种方法来检测它并防止它发生。所以我创建了这个并使用它。效果很好。

Answer 8

我遇到了类似的问题，我的任务是在特定的超时时间内将消息推送到 SQS。我使用了通过另一个线程执行它并通过指定超时来等待其未来对象的简单逻辑。如果超时，这会给我一个 TIMEOUT 异常。

final Future<ISendMessageResult> future = 
timeoutHelperThreadPool.getExecutor().submit(() -> {
  return getQueueStore().sendMessage(request).get();
});
try {
  sendMessageResult = future.get(200, TimeUnit.MILLISECONDS);
  logger.info("SQS_PUSH_SUCCESSFUL");
  return true;

} catch (final TimeoutException e) {
  logger.error("SQS_PUSH_TIMEOUT_EXCEPTION");
}

但在某些情况下，您无法阻止另一个线程执行的代码，并且在这种情况下您会得到真正的负面结果。

例如 - 就我而言，我的请求到达了 SQS，在推送消息时，我的代码逻辑遇到了指定的超时。现在实际上我的消息已被推送到队列中，但我的主线程认为它由于超时异常而失败。
这是一类可以避免而不是解决的问题。就像我的例子一样，我通过提供一个超时来避免它，这在几乎所有情况下都足够了。

如果你想要中断的代码在你的应用程序中，而不是像 API 调用那样的东西，那么你可以简单地使用

future.cancel(true)

但是请记住，java 文档说它确实保证执行将被阻止。

“尝试取消执行此任务。如果任务已完成、已被取消或由于其他原因无法取消，则此尝试将失败。如果成功，且此任务尚未开始当调用 cancel 时，该任务永远不应该运行。如果任务已经启动，则 mayInterruptIfRunning 参数确定是否应该中断执行该任务的线程以尝试停止该任务。”

Answer 9

如果你想要一个 CompletableFuture 方式，你可以有一个类似的方法，

public MyResponseObject retrieveDataFromEndpoint() {

   CompletableFuture<MyResponseObject> endpointCall 
       = CompletableFuture.supplyAsync(() ->
             yourRestService.callEnpoint(withArg1, withArg2));

   try {
       return endpointCall.get(10, TimeUnit.MINUTES);
   } catch (TimeoutException 
               | InterruptedException 
               | ExecutionException e) {
       throw new RuntimeException("Unable to fetch data", e);
   }
}

如果你使用 spring，你可以用 @Retryable 注释该方法，以便在抛出异常时重试该方法三次。

Answer 10

不要将任务放在新线程中并将计时器放在主线程中，而是将计时器放在新线程中并将任务放在主线程中：

public static class TimeOut implements Runnable{
    public void run() {
        Thread.sleep(10000);
        if(taskComplete ==false) {
            System.out.println("Timed Out");
            return;
        }
        else {
            return;
        }
    }
}
public static boolean taskComplete = false;
public static void main(String[] args) {
    TimeOut timeOut = new TimeOut();
    Thread timeOutThread = new Thread(timeOut);
    timeOutThread.start();
    //task starts here
    //task completed
    taskComplete =true;
    while(true) {//do all other stuff }
}

Answer 11

有一种巧妙的方法可以做到这一点。

设置一些布尔字段来指示工作是否完成。然后在代码块之前设置一个计时器，以便在超时后运行一段代码。计时器将检查代码块是否已完成执行，如果没有，则抛出异常。否则它什么也做不了。

当然，代码块的末尾应该将该字段设置为 true 以指示工作已完成。

Answer 12

有一个非常简单的选项，但还没有人提到：

Duration timeout = Duration.ofMinutes(5);
Thread thread = new Thread(() -> {
    // your code here
});
thread.start();
thread.join(timeout.toMillis());
if (thread.isAlive()) {
    thread.interrupt();
    throw new MyTimeoutException();
}

如果运行代码块的线程未能在超时内完成，它将被中断，并且可以抛出您想要的任何异常。

可以编写简单地忽略中断并继续执行的代码。如果您正在处理这个问题无法修复它，那么可以使用thread.stop()，但这可能会破坏您所依赖的任何同步机制。请参阅其 弃用通知。

您还可以从线程捕获异常：

AtomicReference<Throwable> uncaughtException = new AtomicReference<>();
thread.setUncaughtExceptionHandler((t, ex) -> uncaughtException.setRelease(ex));

// ...

Throwable ex = uncaughtException.getAcquire();
if (ex != null) {
    throw ex;
}

Answer 13

我也遇到了这个问题，我的日志打印出“意外的流结束”和“无法从池中获取资源”，
我将brpop的超时设置为30s，redis设置为31s，mysql数据库连接池设置为300s。目前日志上还没有打印这个错误，但是不知道以后会不会报这个错误。不知道对我写入数据库有没有不好的影响