處理線程最大執行時間的最佳方式（Java）

Question

所以，我很好奇。你如何處理設置線程的最大執行時間？在線程池中運行時？

我有幾種技術，但我從來不滿意他們。所以，我想我會問社區他們如何去做。

Answer 1

通常，我只是從線程代碼中定期輪詢一個控制對象。喜歡的東西：

interface ThreadControl { 
    boolean shouldContinue(); 
} 

class Timer implements ThreadControl { 
    public boolean shouldContinue() { 
     // returns false if max_time has elapsed 
    } 
} 

class MyTask implements Runnable { 
    private tc; 
    public MyTask(ThreadControl tc) { 
     this.tc = tc; 
    } 
    public void run() { 
     while (true) { 
      // do stuff 
      if (!tc.shouldContinue()) 
       break; 
     } 
    } 
} 

Answer 2

如何：

提交您Callable爲ExecutorService和保持一個句柄返回Future。

ExecutorService executorService = ... // Create ExecutorService. 
Callable<Result> callable = new MyCallable(); // Create work to be done. 
Future<Result> fut = executorService.submit(callable); 

裹在Delayed一個實現由此Delayed的getDelay(TimeUnit)方法返回所討論的工作的最大執行時間Future。

public class DelayedImpl<T> implements Delayed { 
    private final long maxExecTimeMillis; 
    private final Future<T> future; 

    public DelayedImpl(long maxExecTimeMillis, Future<T> future) { 
    this.maxExecMillis = maxExecMillis; 
    this.future = future; 
    } 

    public TimeUnit getDelay(TimeUnit timeUnit) { 
    return timeUnit.convert(maxExecTimeMillis, TimeUnit.MILLISECONDS); 
    } 

    public Future<T> getFuture() { 
    return future; 
    } 
} 

DelayedImpl impl = new DelayedImpl(3000L, fut); // Max exec. time == 3000ms. 

Add the `DelayedImpl` to a `DelayQueue`. 

Queue<DelayedImpl> queue = new DelayQueue<DelayImpl>(); 
queue.add(impl); 

從隊列中有一個線程反覆take()和檢查每個DelayedImpl的Future是否是通過調用isDone()完整的;如果不是，則取消該任務。

new Thread(new Runnable() { 
    public void run() { 
    while (!Thread.interrupted) { 
     DelayedImpl impl = queue.take(); // Perform blocking take. 
     if (!impl.getFuture().isDone()) { 
     impl.getFuture().cancel(true); 
     } 
    } 
    } 
}).start(); 

主要優點這種方法是，你可以設置每個任務和延遲隊列不同的最長執行時間會自動的執行時間量最小剩餘返回任務。

Answer 3

亞當斯基：

我相信你的延遲接口的實現需要以正常工作的一些調整。如果從對象的實例化過去的時間量超過了最大生命週期，那麼'getDelay（）'的返回值應該返回一個負值。爲了達到這個目的，你需要存儲創建任務的時間（可能開始）。然後每次'getDelay（）'被調用時，計算是否超出了線程的最大生命週期。如：

class DelayedImpl<T> implements Delayed { 

    private Future<T> task; 
    private final long maxExecTimeMinutes = MAX_THREAD_LIFE_MINUTES; 
    private final long startInMillis = System.currentTimeMillis(); 

    private DelayedImpl(Future<T> task) { 
     this.task = task; 
    } 

    public long getDelay(TimeUnit unit) { 
     return unit.convert((startInMillis + maxExecTimeMinutes*60*1000) - System.currentTimeMillis(), TimeUnit.MILLISECONDS); 
    } 

    public int compareTo(Delayed o) { 
     Long thisDelay = getDelay(TimeUnit.MILLISECONDS); 
     Long thatDelay = o.getDelay(TimeUnit.MILLISECONDS); 
     return thisDelay.compareTo(thatDelay); 
    } 

    public Future<T> getTask() { 
     return task; 
    } 
}