Java: Set Timeout on a Certain Block of Code

Java: set timeout on a certain block of code?

Yes, but its generally a very bad idea to force another thread to interrupt on a random line of code. You would only do this if you intend to shutdown the process.

What you can do is to use Thread.interrupt() for a task after a certain amount of time. However, unless the code checks for this it won't work. An ExecutorService can make this easier with Future.cancel(true)

Its much better for the code to time itself and stop when it needs to.

how can I set a timeout to a block in a test (junit)?

Rather than throwing TimeoutException, have it throw your own Exception that extends RuntimeException.

Note that this will kill your timer thread. If this is an issue, use ScheduledExecutorService

How can I interrupt a ServerSocket accept() method?

You can call close() from another thread, and the accept() call will throw a SocketException.

java- timing the execution of a block of code

1st approach:

long startTime = System.nanoTime();
while(System.nanoTime() - startTime < MAX_TIME_IN_NANOSECONDS){
   // your code ...
}

2nd approach

Start your code in thread.

Sleep main thread for as long as you need.

Kill (stop, interrupt) your thread.

How to implement synchronous method timeouts in Java?

You should use ExecutorService to do that

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new Callable() {

    public String call() throws Exception {
        //do operations you want
        return "OK";
    }
});
try {
    System.out.println(future.get(2, TimeUnit.SECONDS)); //timeout is in 2 seconds
} catch (TimeoutException e) {
    System.err.println("Timeout");
}
executor.shutdownNow();

How do I call some blocking method with a timeout in Java?

You could use an Executor:

ExecutorService executor = Executors.newCachedThreadPool();
Callable<Object> task = new Callable<Object>() {
   public Object call() {
      return something.blockingMethod();
   }
};
Future<Object> future = executor.submit(task);
try {
   Object result = future.get(5, TimeUnit.SECONDS); 
} catch (TimeoutException ex) {
   // handle the timeout
} catch (InterruptedException e) {
   // handle the interrupts
} catch (ExecutionException e) {
   // handle other exceptions
} finally {
   future.cancel(true); // may or may not desire this
}

If the future.get doesn't return in 5 seconds, it throws a TimeoutException. The timeout can be configured in seconds, minutes, milliseconds or any unit available as a constant in TimeUnit.

See the JavaDoc for more detail.

How do I force terminate a thread in java with time limit?

Code snippet that I've used to do something similar:

 LOG.info("Time limited task started on monitored thread, with limit (" + limit + ")");
    final ZonedDateTime start = nowUTC();
    final Thread thread = new Thread(toRun);
    thread.setDaemon(true);
    final List<Throwable> exceptions = new ArrayList<>();
    thread.setUncaughtExceptionHandler((t, e) -> {
        exceptions.add(e);
    });
    thread.start();

    // Check and wait for completion.
    while (thread.isAlive()) {
        if (!isWithinLimit(start, nowUTC())) {
            LOG.error("Interrupting thread, did not complete before limit (" + limit + ")");
            try {
                thread.interrupt();
            } catch (Exception e) {
                e.printStackTrace();
            }
            throw new TimeLimitExceedException("Execution limit of " + limit
                    + " exceeded. (Has been running since " + start + ")");
        }
        try {
            Thread.sleep(POLLING_PERIOD.toMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    // If it failed because of an exception, we want to trigger this.
    if (!exceptions.isEmpty()) {
        final Throwable exception = exceptions.get(0);
        if (exception instanceof RuntimeException) {
            throw (RuntimeException) exception;
        } else {
            throw new RuntimeException(exception);
        }
    }
    final Duration runTime = Duration.between(start, nowUTC());
    LOG.info("Time limited task has completed in (" + runTime + ") vs limit of (" + limit
            + ").");

TLDR:
I just start whatever I'm running as a new thread that is set as a daemon (just in case it is the last thing running), then I get a reference to that and poll it, and call thread.interrupt() if it goes over the time limit.

Other context & bells and whistles

• This is part of a class that has some other state, like duration and what it is running
• Also track some exceptions so that it can be spit out at the end if necessary

---

Related Topics