スレッドをタイムアウトする方法
一定時間スレッドを実行したいのですが。その時間内に完了しない場合は、それを強制終了するか、何らかの例外をスローするか、または何らかの方法で処理します。どうすればそれができますか？
this thread から考え出したようにするには、Threadのrun（）メソッド内でTimerTaskを使用します。
これに対するよりよい解決策はありますか？
編集：私がより明確な答えを必要としていたときに賞金を追加する。下記のExecutorServiceコードは私の問題を解決しません。実行後になぜsleep（）しなければならないのですか（いくつかのコード - このコードを処理できません）。コードが完成してsleep（）が中断された場合、どうすればよいでしょうか。
実行する必要があるタスクは私の管理下にはありません。任意のコードにすることができます。問題は、このコードが無限ループに陥る可能性があることです。私はそれが起こりたくありません。だから、私はただ別のスレッドでそのタスクを実行したいのです。親スレッドは、そのスレッドが終了し、タスクのステータス（タイムアウトしたかどうか、何らかの例外が発生したかどうか、または成功したかどうか）を知る必要があるまで待つ必要があります。タスクが無限ループに陥った場合、私の親スレッドは無限に待機し続けますが、これは理想的な状況ではありません。
実際にはExecutorServiceの代わりに Timer を使用してください。これは 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!";
}
}
Future#get() メソッドのtimeout引数でちょっと遊んでください。 5に増やすと、スレッドが終了したことがわかります。タイムアウトをcatch (TimeoutException e)ブロックで傍受することができます。
更新：概念の誤解を明確にするために、sleep()は必須ではありません。これはSSCCE /デモンストレーション目的でのみ使用されます。 sleep()の代わりにあなたの長期実行タスクを実行してください。長期実行タスクの中では、次のようにスレッドが 中断 ではないかどうかを確認する必要があります。
while (!Thread.interrupted()) {
// Do your long running task here.
}
古いタスクに対してこれを行うための100％信頼できる方法はありません。この能力を念頭に置いてタスクを書く必要があります。
ExecutorServiceのようなコアJavaライブラリは、ワーカースレッドで interrupt() を呼び出して非同期タスクをキャンセルします。したがって、たとえば、タスクに何らかのループが含まれている場合は、反復ごとにその 割り込みステータス を確認する必要があります。タスクがI/O操作を行っている場合、それらも割り込み可能であるべきです - そしてそれを設定するのは難しいかもしれません。いずれにせよ、コードは割り込みを積極的にチェックしなければならないことに注意してください。割り込みを設定しても、必ずしも何も起こるわけではありません。
もちろん、タスクが単純なループである場合は、繰り返しごとに現在時刻を確認して、指定されたタイムアウトが経過したときにあきらめることができます。その場合、ワーカースレッドは必要ありません。
ExecutorService のインスタンスを使用することを検討してください。 invokeAll()メソッドとinvokeAny()メソッドは両方ともtimeoutパラメータで利用できます。
タスクが正常に完了したか、タイムアウトになったために、現在のスレッドはメソッドが完了するまでブロックされます（これが望ましいかどうかわからない場合）。何が起こったのかを判断するために、返されたFuture（s）を調べることができます。
BalusCは言った：
更新：概念的な誤解を明確にするために、sleep（）は必要ありません。これはSSCCE /デモンストレーション目的でのみ使用されます。 sleep（）の代わりに、ただ長時間実行しているタスクを実行してください。
しかし、Thread.sleep(4000);をfor (int i = 0; i < 5E8; i++) {}に置き換えた場合、空のループはInterruptedExceptionをスローしないため、コンパイルは行われません。
そして、スレッドが割り込み可能になるためには、InterruptedExceptionをスローする必要があります。
これは私にとって深刻な問題のようです。この答えをどのようにして一般的な長期タスクで機能するように調整するのかわかりません。
追加のために編集しました：私はこれを新しい質問として書き直しました：[ 一定時間後にスレッドを中断します、InterruptedExceptionをスローする必要がありますか？ ]
スレッドコードがあなたの管理下にないと仮定します。
Javaより ドキュメント 上記の通り：
スレッドがThread.interruptに応答しない場合はどうなりますか？
場合によっては、アプリケーション固有のトリックを使用できます。たとえば、スレッドが既知のソケットで待機している場合は、ソケットを閉じてスレッドをすぐに戻すことができます。残念ながら、一般的に機能する手法は本当にありません。 待機中のスレッドがThread.interruptに応答しないすべての状況で、Thread.stopにも応答しないことに注意してください。このような場合には意図的な拒否が含まれます。サービス妨害攻撃、およびthread.stopとthread.interruptが正常に機能しない入出力操作。
一番下の行：
すべてのスレッドが割り込まれる可能性があることを確認してください。そうしないと、設定するフラグがあるなど、スレッドに関する特定の知識が必要になります。 stop()メソッドでインターフェースを定義する - あなたはそれを止めるのに必要なコードと一緒にあなたにタスクが与えられることを要求することができるかもしれません。タスクを停止できなかったときに警告することもできます。
私は少し前にこのためにヘルパークラスを作成しました。よく働く：
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;
}
}
}
}
これは次のように呼ばれます。
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) {}
私はあなたが適切な並行処理メカニズムを見てみるべきだと思います（無限ループに走っているスレッドはそれ自体は良く聞こえないでしょう、ところで）。 "kill"または "stop" Threads トピックについて少し読んでください。
あなたが説明していることは、「ランデブー」のように聞こえるので、 CyclicBarrier を見てみるとよいでしょう。
あなたの問題を解決できる他の構造体（例えば CountDownLatch を使うなど）があるかもしれません（片方のスレッドがラッチのタイムアウトを待っていて、もう片方がうまくいったらラッチをカウントダウンするべきです）。タイムアウト後またはラッチカウントダウンが呼び出されたときに、最初のスレッドを解放します。
私はふつうこの分野で2冊の本を推薦します： Javaでの並行プログラミング と 実践でのJava並行処理 。
問題を解決する方法を示すコードを投稿します。例として、私はファイルを読んでいます。このメソッドを他の操作に使用することもできますが、メインの操作が中断されるようにkill（）メソッドを実装する必要があります。
それが役に立てば幸い
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!");
}
}
}
よろしく
私が言及したことを見たことがないことの一つは、スレッドを殺すことは一般的に悪い考えであるということです。スレッド化されたメソッドを作るためのテクニックがいくつかありますきれいに打ち切ることができます、それはただタイムアウト後にスレッドを殺すこととは異なります。
あなたが提案していることのリスクは、あなたがそれを殺したときにスレッドがどのような状態になるのかおそらくわからないということです - あなたは不安定性を導入する危険性があります。より良い解決策は、あなたのスレッド化されたコードがそれ自身ハングしないか、中止要求にうまく反応するかのどちらかを確かめることです。
BalusCの素晴らしい答え：
しかし、タイムアウト自体がスレッド自体に割り込むことはありません。タスク内でwhile（！Thread.interrupted（））をチェックしていても。スレッドが確実に停止されるようにしたい場合は、タイムアウト例外がキャッチされたときにfuture.cancel（）が必ず呼び出されるようにする必要があります。
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!!");
}
}
}
これが私の本当に使いやすいヘルパークラスへの実行または呼び出しのJavaコード:-)
これは、優れた 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;
}
}
次のスニペットは、別のスレッドで操作を開始してから、操作が完了するまで最大10秒待ちます。操作が時間内に完了しない場合、コードは操作を取り消そうとし、それからその陽気な方法を続けます。操作を簡単にキャンセルできない場合でも、親スレッドは子スレッドが終了するのを待ちません。
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
}
getExecutorService()メソッドはさまざまな方法で実装できます。特別な要件がない場合は、スレッドプールにExecutors.newCachedThreadPool()を呼び出すだけで、スレッド数に上限はありません。
答えは主にタスク自体にかかっていると思います。
- それは何度も何度も1つのタスクをやっていますか？
- 期限切れになった直後にタイムアウトが現在実行中のタスクに割り込む必要がありますか？
最初の答えが「はい」で、2番目の答えが「いいえ」の場合は、次のように単純にすることができます。
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();
}
}
これが選択肢でない場合は、要件を絞り込んでください - またはコードを表示してください。
さて、このような問題に出会うでしょう。それは絵をデコードするために起こります。デコード処理には時間がかかりすぎて画面が真っ黒になります。 l時間管理者を追加する。時間が長すぎる場合は、現在のスレッドからポップアップする以下は差分です。
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);
私は、それによって実行されたすべてのタイムアウトRunnablesを中断することができるExecutorServiceを探していましたが、何も見つかりませんでした。数時間後、私は以下のように作成しました。このクラスは堅牢性を高めるために修正することができます。
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();
}
}
使用法：
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();
}
BalusC で与えられる解法では、メインスレッドはタイムアウト期間ブロックされたままになります。複数のスレッドを持つスレッドプールがある場合、使用するスレッドと同じ数の追加スレッドが必要になります。 Future.get（long timeout、TimeUnit unit） スレッドを待機して閉じる呼び出しをブロックタイムアウト期間を超えた場合.
この問題に対する一般的な解決策は、タイムアウト機能を追加できるThreadPoolExecutorデコレータを作成することです。このDecoratorクラスはThreadPoolExecutorと同じ数のスレッドを作成する必要があります。これらのスレッドはすべてThreadPoolExecutorを待機して閉じるためにのみ使用する必要があります。
ジェネリッククラスは以下のように実装する必要があります。
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();
}
}
上記のデコレータは以下のように使用できます。
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);
};
}
}
私は同じ問題を抱えていました。だから私はこのような簡単な解決策を思いついた。
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;
}
}
Ifブロックが制限時間内に実行されなかったことを保証します。プロセスは終了し、例外をスローします。
例：
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
}