How to timeout a thread

I want to run a thread for some fixed amount of time. If it is not completed within that time, I want to either kill it, throw some exception, or handle it in some way. How can it be done?

One way of doing it as I figured out from this thread is to use a TimerTask inside the run() method of the Thread.

Are there any better solutions for this?

 
EDIT: Adding a bounty as I needed a clearer answer. The ExecutorService code given below does not address my problem. Why should I sleep() after executing (some code - I have no handle over this piece of code)? If the code is completed and the sleep() is interrupted, how can that be a timeOut?

The task that needs to be executed is not in my control. It can be any piece of code. The problem is this piece of code might run into an infinite loop. I don't want that to happen. So, I just want to run that task in a separate thread. The parent thread has to wait till that thread finishes and needs to know the status of the task (i.e whether it timed out or some exception occured or if its a success). If the task goes into an infinite loop, my parent thread keeps on waiting indefinitely, which is not an ideal situation.

Indeed rather use ExecutorService instead of Timer, here's an SSCCE:

package com.stackoverflow.q2275443;

import java.util.concurrent.Callable;
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 Test {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new Task());

        try {
            System.out.println("Started..");
            System.out.println(future.get(3, TimeUnit.SECONDS));
            System.out.println("Finished!");
        } catch (TimeoutException e) {
            future.cancel(true);
            System.out.println("Terminated!");
        }

        executor.shutdownNow();
    }
}

class Task implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(4000); // Just to demo a long running task of 4 seconds.
        return "Ready!";
    }
}

Play a bit with the timeout argument in Future#get() method, e.g. increase it to 5 and you'll see that the thread finishes. You can intercept the timeout in the catch (TimeoutException e) block.

Update: to clarify a conceptual misunderstanding, the sleep() is not required. It is just used for SSCCE/demonstration purposes. Just do your long running task right there in place of sleep(). Inside your long running task, you should be checking if the thread is not interrupted as follows:

while (!Thread.interrupted()) {
    // Do your long running task here.
}

There isn't a 100% reliable way to do this for any old task. The task has to be written with this ability in mind.

Core Java libraries like ExecutorService cancel asynchronous tasks with interrupt() calls on the worker thread. So, for example, if the task contains some sort of loop, you should be checking its interrupt status on each iteration. If the task is doing I/O operations, they should be interruptible too—and setting that up can be tricky. In any case, keep in mind that code has to actively check for interrupts; setting an interrupt doesn't necessarily do anything.

Of course, if your task is some simple loop, you can just check the current time at each iteration and give up when a specified timeout has elapsed. A worker thread isn't needed in that case.

Consider using an instance of ExecutorService. Both invokeAll() and invokeAny() methods are available with a timeout parameter.

The current thread will block until the method completes (not sure if this is desirable) either because the task(s) completed normally or the timeout was reached. You can inspect the returned Future(s) to determine what happened.

Assuming the thread code is out of your control:

From the Java documentation mentioned above:

> What if a thread doesn't respond to Thread.interrupt? > > In some cases, you can use application specific tricks. For example, > if a thread is waiting on a known socket, you can close the socket to > cause the thread to return immediately. Unfortunately, there really > isn't any technique that works in general. It should be noted that in > all situations where a waiting thread doesn't respond to > Thread.interrupt, it wouldn't respond to Thread.stop either. Such > cases include deliberate denial-of-service attacks, and I/O operations > for which thread.stop and thread.interrupt do not work properly.

Bottom Line:

Make sure all threads can be interrupted, or else you need specific knowledge of the thread - like having a flag to set. Maybe you can require that the task be given to you along with the code needed to stop it - define an interface with a stop() method. You can also warn when you failed to stop a task.

BalusC said:

> Update: to clarify a conceptual misunderstanding, the sleep() is not required. It is just used for SSCCE/demonstration purposes. Just do your long running task right there in place of sleep().

But if you replace Thread.sleep(4000); with for (int i = 0; i < 5E8; i++) {} then it doesn't compile, because the empty loop doesn't throw an InterruptedException.

And for the thread to be interruptible, it needs to throw an InterruptedException.

This seems like a serious problem to me. I can't see how to adapt this answer to work with a general long-running task.

Edited to add: I reasked this as a new question: [ https://stackoverflow.com/questions/10031607/interrupting-a-thread-after-fixed-time-does-it-have-to-throw-interruptedexcepti ]

I think you should take a look at proper concurrency handling mechanisms (threads running into infinite loops doesn't sound good per se, btw). Make sure you read a little about the "killing" or "stopping" Threads topic.

What you are describing,sound very much like a "rendezvous", so you may want to take a look at the CyclicBarrier.

There may be other constructs (like using CountDownLatch for example) that can resolve your problem (one thread waiting with a timeout for the latch, the other should count down the latch if it has done it's work, which would release your first thread either after a timeout or when the latch countdown is invoked).

I usually recommend two books in this area: Concurrent Programming in Java and Java Concurrency in Practice.

I created a helper class just for this some time ago. Works great:

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
 * TimeOut class - used for stopping a thread that is taking too long
 * @author Peter Goransson
 *
 */
public class TimeOut {

	Thread interrupter;
	Thread target;
	long timeout;
	boolean success;
	boolean forceStop;
	
	CyclicBarrier barrier;
	
	/**
	 * 
	 * @param target The Runnable target to be executed
	 * @param timeout The time in milliseconds before target will be interrupted or stopped
	 * @param forceStop If true, will Thread.stop() this target instead of just interrupt() 
	 */
	public TimeOut(Runnable target, long timeout, boolean forceStop) {		
		this.timeout = timeout;
		this.forceStop = forceStop;
		
		this.target = new Thread(target);		
		this.interrupter = new Thread(new Interrupter());
		
		barrier = new CyclicBarrier(2); // There will always be just 2 threads waiting on this barrier
	}
	
	public boolean execute() throws InterruptedException {	
		
		// Start target and interrupter
		target.start();
		interrupter.start();
		
		// Wait for target to finish or be interrupted by interrupter
		target.join();	
				
		interrupter.interrupt(); // stop the interrupter	
		try {
			barrier.await(); // Need to wait on this barrier to make sure status is set
		} catch (BrokenBarrierException e) {
			// Something horrible happened, assume we failed
			success = false;
		} 

		return success; // status is set in the Interrupter inner class
	}
	
	private class Interrupter implements Runnable {
		
		Interrupter() {}

		public void run() {
			try {
				Thread.sleep(timeout); // Wait for timeout period and then kill this target
				if (forceStop) {
				  target.stop(); // Need to use stop instead of interrupt since we're trying to kill this thread
				}
				else {
					target.interrupt(); // Gracefully interrupt the waiting thread
				}
				System.out.println("done");				
				success = false;
			} catch (InterruptedException e) {
				success = true;
			}
			

			try {
				barrier.await(); // Need to wait on this barrier
			} catch (InterruptedException e) {
				// If the Child and Interrupter finish at the exact same millisecond we'll get here
				// In this weird case assume it failed
				success = false;				
			} 
			catch (BrokenBarrierException e) {
				// Something horrible happened, assume we failed
				success = false;
			}

		}

	}
}

It is called like this:

long timeout = 10000; // number of milliseconds before timeout
TimeOut t = new TimeOut(new PhotoProcessor(filePath, params), timeout, true);
try {    		    		
  boolean sucess = t.execute(); // Will return false if this times out
  if (!sucess) {
    // This thread timed out
  }
  else {
    // This thread ran completely and did not timeout
  }
} catch (InterruptedException e) {}  

I post you a piece of code which show a way how to solve the problem. As exemple I'm reading a file. You could use this method for another operation, but you need to implements the kill() method so that the main operation will be interrupted.

hope it helps

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;




/**




Main class

@author el





/
public class Main {
/*
* Thread which perform the task which should be timed out.
*
* @author el
*
/
public static class MainThread extends Thread {
/*
* For example reading a file. File to read.
/
final private File fileToRead;
/*
* InputStream from the file.
/
final private InputStream myInputStream;
/*
* Thread for timeout.
*/
final private TimeOutThread timeOutThread;



	/**
	 * true if the thread has not ended.
	 */
	boolean isRunning = true;

	/**
	 * true if all tasks where done.
	 */
	boolean everythingDone = false;

	/**
	 * if every thing could not be done, an {@link Exception} may have
	 * Happens.
	 */
	Throwable endedWithException = null;

	/**
	 * Constructor.
	 * 
	 * @param file
	 * @throws FileNotFoundException
	 */
	MainThread(File file) throws FileNotFoundException {
		setDaemon(false);
		fileToRead = file;
		// open the file stream.
		myInputStream = new FileInputStream(fileToRead);
		// Instantiate the timeout thread.
		timeOutThread = new TimeOutThread(10000, this);
	}

	/**
	 * Used by the {@link TimeOutThread}.
	 */
	public void kill() {
		if (isRunning) {
			isRunning = false;
			if (myInputStream != null) {
				try {
					// close the stream, it may be the problem.
					myInputStream.close();
				} catch (IOException e) {
					// Not interesting
					System.out.println(e.toString());
				}
			}
			synchronized (this) {
				notify();
			}
		}
	}

	/**
	 * The task which should be timed out.
	 */
	@Override
	public void run() {
		timeOutThread.start();
		int bytes = 0;
		try {
			// do something
			while (myInputStream.read() >= 0) {
				// may block the thread.
				myInputStream.read();
				bytes++;
				// simulate a slow stream.
				synchronized (this) {
					wait(10);
				}
			}
			everythingDone = true;
		} catch (IOException e) {
			endedWithException = e;
		} catch (InterruptedException e) {
			endedWithException = e;
		} finally {
			timeOutThread.kill();
			System.out.println("-->read " + bytes + " bytes.");
			isRunning = false;
			synchronized (this) {
				notifyAll();
			}
		}
	}
}

/**
 * Timeout Thread. Kill the main task if necessary.
 * 
 * @author el
 * 
 */
public static class TimeOutThread extends Thread {
	final long timeout;
	final MainThread controlledObj;

	TimeOutThread(long timeout, MainThread controlledObj) {
		setDaemon(true);
		this.timeout = timeout;
		this.controlledObj = controlledObj;
	}

	boolean isRunning = true;

	/**
	 * If we done need the {@link TimeOutThread} thread, we may kill it.
	 */
	public void kill() {
		isRunning = false;
		synchronized (this) {
			notify();
		}
	}

	/**
	 * 
	 */
	@Override
	public void run() {
		long deltaT = 0l;
		try {
			long start = System.currentTimeMillis();
			while (isRunning && deltaT < timeout) {
				synchronized (this) {
					wait(Math.max(100, timeout - deltaT));
				}
				deltaT = System.currentTimeMillis() - start;
			}
		} catch (InterruptedException e) {
			// If the thread is interrupted,
			// you may not want to kill the main thread,
			// but probably yes.
		} finally {
			isRunning = false;
		}
		controlledObj.kill();
	}
}

/**
 * Start the main task and wait for the end.
 * 
 * @param args
 * @throws FileNotFoundException
 */
public static void main(String[] args) throws FileNotFoundException {
	long start = System.currentTimeMillis();
	MainThread main = new MainThread(new File(args[0]));
	main.start();
	try {
		while (main.isRunning) {
			synchronized (main) {
				main.wait(1000);
			}
		}
		long stop = System.currentTimeMillis();

		if (main.everythingDone)
			System.out.println("all done in " + (stop - start) + " ms.");
		else {
			System.out.println("could not do everything in "
					+ (stop - start) + " ms.");
			if (main.endedWithException != null)
				main.endedWithException.printStackTrace();
		}
	} catch (InterruptedException e) {
		System.out.println("You've killed me!");
	}
}




}
}

Regards

Here is my really simple to use helper class to run or call piece of Java code :-)

This is based on the excellent answer from BalusC

package com.mycompany.util.concurrent;

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;

/**
 * Calling {@link Callable#call()} or Running {@link Runnable#run()} code
 * with a timeout based on {@link Future#get(long, TimeUnit))}
 * @author pascaldalfarra
 *
 */
public class CallableHelper
{

	private CallableHelper()
	{
	}

	public static final void run(final Runnable runnable, int timeoutInSeconds)
	{
		run(runnable, null, timeoutInSeconds);
	}
	
	public static final void run(final Runnable runnable, Runnable timeoutCallback, int timeoutInSeconds)
	{
		call(new Callable<Void>()
		{
			@Override
			public Void call() throws Exception
			{
				runnable.run();
				return null;
			}
		}, timeoutCallback, timeoutInSeconds); 
	}
	
	public static final <T> T call(final Callable<T> callable, int timeoutInSeconds)
	{
		return call(callable, null, timeoutInSeconds); 
	}
	
	public static final <T> T call(final Callable<T> callable, Runnable timeoutCallback, int timeoutInSeconds)
	{
		ExecutorService executor = Executors.newSingleThreadExecutor();
		try
		{
			Future<T> future = executor.submit(callable);
			T result = future.get(timeoutInSeconds, TimeUnit.SECONDS);
			System.out.println("CallableHelper - Finished!");
			return result;
		}
		catch (TimeoutException e)
		{
			System.out.println("CallableHelper - TimeoutException!");
			if(timeoutCallback != null)
			{
				timeoutCallback.run();
			}
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		catch (ExecutionException e)
		{
			e.printStackTrace();
		}
		finally
		{
			executor.shutdownNow();
			executor = null;
		}
		
		return null;
	}

}

In the solution given by BalusC, the main thread will stay blocked for the timeout period. If you have a thread pool with more than one thread, you will need the same number of additional thread that will be using Future.get(long timeout,TimeUnit unit) blocking call to wait and close the thread if it exceeds the timeout period.

A generic solution to this problem is to create a ThreadPoolExecutor Decorator that can add the timeout functionality. This Decorator class should create as many threads as ThreadPoolExecutor has, and all these threads should be used only to wait and close the ThreadPoolExecutor.

The generic class should be implemented like below:

import java.util.List;
import java.util.concurrent.*;

public class TimeoutThreadPoolDecorator extends ThreadPoolExecutor {


    private final ThreadPoolExecutor commandThreadpool;
    private final long timeout;
    private final TimeUnit unit;

    public TimeoutThreadPoolDecorator(ThreadPoolExecutor threadpool,
                                      long timeout,
                                      TimeUnit unit ){
        super(  threadpool.getCorePoolSize(),
                threadpool.getMaximumPoolSize(),
                threadpool.getKeepAliveTime(TimeUnit.MILLISECONDS),
                TimeUnit.MILLISECONDS,
                threadpool.getQueue());

        this.commandThreadpool = threadpool;
        this.timeout=timeout;
        this.unit=unit;
    }

    @Override
    public void execute(Runnable command) {
        super.execute(() -> {
            Future<?> future = commandThreadpool.submit(command);
            try {
                future.get(timeout, unit);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } catch (ExecutionException | TimeoutException e) {
                throw new RejectedExecutionException(e);
            } finally {
                future.cancel(true);
            }
        });
    }

    @Override
    public void setCorePoolSize(int corePoolSize) {
        super.setCorePoolSize(corePoolSize);
        commandThreadpool.setCorePoolSize(corePoolSize);
    }

    @Override
    public void setThreadFactory(ThreadFactory threadFactory) {
        super.setThreadFactory(threadFactory);
        commandThreadpool.setThreadFactory(threadFactory);
    }

    @Override
    public void setMaximumPoolSize(int maximumPoolSize) {
        super.setMaximumPoolSize(maximumPoolSize);
        commandThreadpool.setMaximumPoolSize(maximumPoolSize);
    }

    @Override
    public void setKeepAliveTime(long time, TimeUnit unit) {
        super.setKeepAliveTime(time, unit);
        commandThreadpool.setKeepAliveTime(time, unit);
    }

    @Override
    public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
        super.setRejectedExecutionHandler(handler);
        commandThreadpool.setRejectedExecutionHandler(handler);
    }

    @Override
    public List<Runnable> shutdownNow() {
        List<Runnable> taskList = super.shutdownNow();
        taskList.addAll(commandThreadpool.shutdownNow());
        return taskList;
    }

    @Override
    public void shutdown() {
        super.shutdown();
        commandThreadpool.shutdown();
    }
}

The above decorator can be used as below:

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {

    public static void main(String[] args){

        long timeout = 2000;

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 10, 0, TimeUnit.MILLISECONDS, new SynchronousQueue<>(true));

        threadPool = new TimeoutThreadPoolDecorator( threadPool ,
                timeout,
                TimeUnit.MILLISECONDS);


        threadPool.execute(command(1000));
        threadPool.execute(command(1500));
        threadPool.execute(command(2100));
        threadPool.execute(command(2001));

        while(threadPool.getActiveCount()>0);
        threadPool.shutdown();


    }

    private static Runnable command(int i) {

        return () -> {
            System.out.println("Running Thread:"+Thread.currentThread().getName());
            System.out.println("Starting command with sleep:"+i);
            try {
                Thread.sleep(i);
            } catch (InterruptedException e) {
                System.out.println("Thread "+Thread.currentThread().getName()+" with sleep of "+i+" is Interrupted!!!");
                return;
            }
            System.out.println("Completing Thread "+Thread.currentThread().getName()+" after sleep of "+i);
        };

    }
}

One thing that I've not seen mentioned is that killing threads is generally a Bad Idea. There are techniques for making threaded methods cleanly abortable, but that's different to just killing a thread after a timeout.

The risk with what you're suggesting is that you probably don't know what state the thread will be in when you kill it - so you risk introducing instability. A better solution is to make sure your threaded code either doesn't hang itself, or will respond nicely to an abort request.

The following snippet will start an operation in a separate thread, then wait for up to 10 seconds for the operation to complete. If the operation does not complete in time, the code will attempt to cancel the operation, then continue on its merry way. Even if the operation cannot be cancelled easily, the parent thread will not wait for the child thread to terminate.

ExecutorService executorService = getExecutorService();
Future<SomeClass> future = executorService.submit(new Callable<SomeClass>() {
    public SomeClass call() {
        // Perform long-running task, return result. The code should check
        // interrupt status regularly, to facilitate cancellation.
    }
});
try {
    // Real life code should define the timeout as a constant or
    // retrieve it from configuration
    SomeClass result = future.get(10, TimeUnit.SECONDS);
    // Do something with the result
} catch (TimeoutException e) {
    future.cancel(true);
    // Perform other error handling, e.g. logging, throwing an exception
}

The getExecutorService() method can be implemented in a number of ways. If you do not have any particular requirements, you can simply call Executors.newCachedThreadPool() for thread pooling with no upper limit on the number of threads.

Great answer by BalusC's:

but Just to add that the timeout itself does not interrupt the thread itself. even if you are checking with while(!Thread.interrupted()) in your task. if you want to make sure thread is stopped you should also make sure future.cancel() is invoked when timeout exception is catch.

package com.stackoverflow.q2275443; 
 
import java.util.concurrent.Callable;
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 Test { 
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(new Task());
 
        try { 
            System.out.println("Started..");
            System.out.println(future.get(3, TimeUnit.SECONDS));
            System.out.println("Finished!");
        } catch (TimeoutException e) {
            //Without the below cancel the thread will continue to live 
            // even though the timeout exception thrown.
            future.cancel();
            System.out.println("Terminated!");
        } 
 
        executor.shutdownNow();
    } 
} 
 
class Task implements Callable<String> {
    @Override 
    public String call() throws Exception {
      while(!Thread.currentThread.isInterrupted()){
          System.out.println("Im still running baby!!");
      }          
    } 
} 

I think the answer mainly depends on the task itself.

• Is it doing one task over and over again?
• Is it necessary that the timeout interrupts a currently running task immediately after it expires?

If the first answer is yes and the second is no, you could keep it as simple as this:

public class Main {

    private static final class TimeoutTask extends Thread {
        private final long _timeoutMs;
        private Runnable _runnable;

        private TimeoutTask(long timeoutMs, Runnable runnable) {
            _timeoutMs = timeoutMs;
            _runnable = runnable;
        }

        @Override
        public void run() {
            long start = System.currentTimeMillis();
            while (System.currentTimeMillis() < (start + _timeoutMs)) {
                _runnable.run();
            }
            System.out.println("execution took " + (System.currentTimeMillis() - start) +" ms");
        }

    }

    public static void main(String[] args) throws Exception {
        new TimeoutTask(2000L, new Runnable() {
            
            @Override
            public void run() {
                System.out.println("doing something ...");
                try {
                    // pretend it's taking somewhat longer than it really does
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }).start();
    }
}

If this isn't an option, please narrow your requirements - or show some code.

I was looking for an ExecutorService that can interrupt all timed out Runnables executed by it, but found none. After a few hours I created one as below. This class can be modified to enhance robustness.

public class TimedExecutorService extends ThreadPoolExecutor {
	long timeout;
	public TimedExecutorService(int numThreads, long timeout, TimeUnit unit) {
		super(numThreads, numThreads, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(numThreads + 1));
		this.timeout = unit.toMillis(timeout);
	}

	@Override
	protected void beforeExecute(Thread thread, Runnable runnable) {
		Thread interruptionThread = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					// Wait until timeout and interrupt this thread
					Thread.sleep(timeout);
					System.out.println("The runnable times out.");
					thread.interrupt();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		interruptionThread.start();
	}
}

Usage:

public static void main(String[] args) {

	Runnable abcdRunnable = new Runnable() {
		@Override
		public void run() {
			System.out.println("abcdRunnable started");
			try {
				Thread.sleep(20000);
			} catch (InterruptedException e) {
				// logger.info("The runnable times out.");
			}
			System.out.println("abcdRunnable ended");
		}
	};
	
	Runnable xyzwRunnable = new Runnable() {
		@Override
		public void run() {
			System.out.println("xyzwRunnable started");
			try {
				Thread.sleep(20000);
			} catch (InterruptedException e) {
				// logger.info("The runnable times out.");
			}
			System.out.println("xyzwRunnable ended");
		}
	};

	int numThreads = 2, timeout = 5;
	ExecutorService timedExecutor = new TimedExecutorService(numThreads, timeout, TimeUnit.SECONDS);
	timedExecutor.execute(abcdRunnable);
	timedExecutor.execute(xyzwRunnable);
	timedExecutor.shutdown();
}

Now , l meet a issue like this. It happens to decode picture. The process of decode takes too much time that the screen keep black. l add a time controler: when the time is too long, then pop up from the current Thread. The following is the diff:

   ExecutorService executor = Executors.newSingleThreadExecutor();
   Future<Bitmap> future = executor.submit(new Callable<Bitmap>() {
       @Override
       public Bitmap call() throws Exception {
       Bitmap bitmap = decodeAndScaleBitmapFromStream(context, inputUri);// do some time consuming operation
       return null;
            }
       });
       try {
           Bitmap result = future.get(1, TimeUnit.SECONDS);
       } catch (TimeoutException e){
           future.cancel(true);
       }
       executor.shutdown();
       return (bitmap!= null);

I had the same problem. So i came up with a simple solution like this.

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

Guarantees that if block didn't execute within the time limit. the process will terminate and throws an exception.

example :

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 
            }
        };
        
        timeoutBlock.addBlock(block);// execute the runnable block 
        
    } catch (Throwable e) {
        //catch the exception here . Which is block didn't execute within the time limit
    }