![](/img/trans.png)
[英]Why future .isDone() must after the executorService.shutdown()
[英]How to run outstanding tasks immediately after ExecutorService.shutdown()?
我有一個ScheduledExecutorService
,其中的任務計划在一小時內執行。 如何獲取未完成任務的列表,以便我可以強制它們立即運行?
我相信shutdown()
會等待一個小時,看起來shutdownNow()
會返回一個無法運行的Runnable列表,因為Runnable實現會檢查Executor state,當它注意到它已經關閉Runnable時拒絕運行. 有關實際實現,請參閱ScheduledThreadPoolExecutor.ScheduledFutureTask.run()
。
有任何想法嗎?
我接受了 Mark Peters 的回答,實現了所有抽象方法,增加了線程安全性,並盡可能尊重底層的 ScheduledThreadPoolExecutor 配置。
/**
* Overrides shutdown() to run outstanding tasks immediately.
*
* @author Gili Tzabari
*/
public class RunOnShutdownScheduledExecutorService extends AbstractExecutorService
implements ScheduledExecutorService
{
private final ScheduledExecutorService delegate;
private final ScheduledThreadPoolExecutor scheduledThreadPoolExecutor;
private final ExecutorService immediateService;
private final ConcurrentMap<Future<?>, Callable<?>> tasks = Maps.newConcurrentMap();
/**
* Creates a new RunOnShutdownScheduledExecutorService.
*
* @param delegate the executor to delegate to
*/
public RunOnShutdownScheduledExecutorService(ScheduledExecutorService delegate)
{
Preconditions.checkNotNull(delegate, "delegate may not be null");
this.delegate = delegate;
if (delegate instanceof ScheduledThreadPoolExecutor)
{
this.scheduledThreadPoolExecutor = (ScheduledThreadPoolExecutor) delegate;
this.immediateService = Executors.newFixedThreadPool(scheduledThreadPoolExecutor.
getCorePoolSize(), scheduledThreadPoolExecutor.getThreadFactory());
}
else
{
scheduledThreadPoolExecutor = null;
this.immediateService = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().
setNameFormat(RunOnShutdownScheduledExecutorService.class.getName() + "-%d").build());
}
}
@Override
public boolean isShutdown()
{
return delegate.isShutdown();
}
@Override
public boolean isTerminated()
{
return delegate.isTerminated();
}
@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException
{
long before = System.nanoTime();
if (!delegate.awaitTermination(timeout, unit))
return false;
long after = System.nanoTime();
long timeLeft = timeout - unit.convert(after - before, TimeUnit.NANOSECONDS);
return immediateService.awaitTermination(timeLeft, unit);
}
@Override
public void execute(Runnable command)
{
delegate.execute(command);
}
@Override
public ScheduledFuture<?> schedule(final Runnable command, long delay, TimeUnit unit)
{
CleaningRunnable decorated = new CleaningRunnable(command);
ScheduledFuture<?> future = delegate.schedule(decorated, delay, unit);
decorated.setFuture(future);
tasks.put(future, Executors.callable(command));
return new CleaningScheduledFuture<>(future);
}
@Override
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
{
CallableWithFuture<V> decorated = new CallableWithFuture<>(callable);
ScheduledFuture<V> future = delegate.schedule(decorated, delay, unit);
decorated.setFuture(future);
tasks.put(future, callable);
return new CleaningScheduledFuture<>(future);
}
@Override
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period,
TimeUnit unit)
{
CleaningRunnable decorated = new CleaningRunnable(command);
ScheduledFuture<?> future = delegate.scheduleAtFixedRate(decorated, initialDelay, period, unit);
decorated.setFuture(future);
tasks.put(future, Executors.callable(command));
return new CleaningScheduledFuture<>(future);
}
@Override
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay,
TimeUnit unit)
{
CleaningRunnable decorated = new CleaningRunnable(command);
ScheduledFuture<?> future =
delegate.scheduleWithFixedDelay(decorated, initialDelay, delay, unit);
decorated.setFuture(future);
tasks.put(future, Executors.callable(command));
return new CleaningScheduledFuture<>(future);
}
@Override
public synchronized void shutdown()
{
if (delegate.isShutdown())
return;
if (scheduledThreadPoolExecutor != null)
{
// WORKAROUND: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7069418
//
// Cancel waiting scheduled tasks, otherwise executor won't shut down
scheduledThreadPoolExecutor.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
}
delegate.shutdown();
// Users will not be able to cancel() Futures past this point so we're guaranteed that
// "tasks" will not be modified.
final List<Callable<?>> outstandingTasks = Lists.newArrayList();
for (Map.Entry<Future<?>, Callable<?>> entry: tasks.entrySet())
{
Future<?> future = entry.getKey();
Callable<?> task = entry.getValue();
if (future.isDone() && future.isCancelled())
{
// Task called by the underlying executor, not the user. See CleaningScheduledFuture.
outstandingTasks.add(task);
}
}
tasks.clear();
if (outstandingTasks.isEmpty())
{
immediateService.shutdown();
return;
}
immediateService.submit(new Callable<Void>()
{
@Override
public Void call() throws Exception
{
delegate.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
// Execute outstanding tasks only after the delegate executor finishes shutting down
for (Callable<?> task: outstandingTasks)
immediateService.submit(task);
immediateService.shutdown();
return null;
}
});
}
@Override
public List<Runnable> shutdownNow()
{
return delegate.shutdownNow();
}
/**
* A Runnable that removes its future when running.
*/
private class CleaningRunnable implements Runnable
{
private final Runnable delegate;
private Future<?> future;
/**
* Creates a new RunnableWithFuture.
*
* @param delegate the Runnable to delegate to
* @throws NullPointerException if delegate is null
*/
public CleaningRunnable(Runnable delegate)
{
Preconditions.checkNotNull(delegate, "delegate may not be null");
this.delegate = delegate;
}
/**
* Associates a Future with the runnable.
*
* @param future a future
*/
public void setFuture(Future<?> future)
{
this.future = future;
}
@Override
public void run()
{
tasks.remove(future);
delegate.run();
}
}
/**
* A Callable that removes its future when running.
*/
private class CallableWithFuture<V> implements Callable<V>
{
private final Callable<V> delegate;
private Future<V> future;
/**
* Creates a new CallableWithFuture.
*
* @param delegate the Callable to delegate to
* @throws NullPointerException if delegate is null
*/
public CallableWithFuture(Callable<V> delegate)
{
Preconditions.checkNotNull(delegate, "delegate may not be null");
this.delegate = delegate;
}
/**
* Associates a Future with the runnable.
*
* @param future a future
*/
public void setFuture(Future<V> future)
{
this.future = future;
}
@Override
public V call() throws Exception
{
tasks.remove(future);
return delegate.call();
}
}
/**
* A ScheduledFuture that removes its future when canceling.
*
* This allows us to differentiate between tasks canceled by the user and the underlying
* executor. Tasks canceled by the user are removed from "tasks".
*
* @param <V> The result type returned by this Future
*/
private class CleaningScheduledFuture<V> implements ScheduledFuture<V>
{
private final ScheduledFuture<V> delegate;
/**
* Creates a new MyScheduledFuture.
*
* @param delegate the future to delegate to
* @throws NullPointerException if delegate is null
*/
public CleaningScheduledFuture(ScheduledFuture<V> delegate)
{
Preconditions.checkNotNull(delegate, "delegate may not be null");
this.delegate = delegate;
}
@Override
public long getDelay(TimeUnit unit)
{
return delegate.getDelay(unit);
}
@Override
public int compareTo(Delayed o)
{
return delegate.compareTo(o);
}
@Override
public boolean cancel(boolean mayInterruptIfRunning)
{
boolean result = delegate.cancel(mayInterruptIfRunning);
if (result)
{
// Tasks canceled by users are removed from "tasks"
tasks.remove(delegate);
}
return result;
}
@Override
public boolean isCancelled()
{
return delegate.isCancelled();
}
@Override
public boolean isDone()
{
return delegate.isDone();
}
@Override
public V get() throws InterruptedException, ExecutionException
{
return delegate.get();
}
@Override
public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException,
TimeoutException
{
return delegate.get(timeout, unit);
}
}
}
好問題。 不過,看起來您可能需要自己拼湊一個解決方案。
一種選擇可能是使用您自己的ScheduledExecutorService
ScheduledThreadPoolExecutor
當需要關閉服務時,取消任何可以取消的任務,而是將它們發送到將立即執行它們的服務。 然后shutdown()
該服務。
這是一些非常粗略的代碼,可以說明我的意思,盡管我警告您這里可能存在陷阱,因為它是在幾分鍾內完成的。 特別是,我沒有付出太多努力來確保這是線程安全的。
class RunOnShutdownScheduledExecutorService extends AbstractExecutorService implements ScheduledExecutorService {
private final ScheduledExecutorService delegateService;
private Map<Future<?>, Runnable> scheduledFutures =
Collections.synchronizedMap(new IdentityHashMap<Future<?>, Runnable>());
public RunOnShutdownScheduledExecutorService(ScheduledExecutorService delegateService) {
this.delegateService = delegateService;
}
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
ScheduledFuture<?> future = delegateService.schedule(command, delay, unit);
scheduledFutures.put(future, command);
return future;
}
public void shutdown() {
delegateService.shutdown();
ExecutorService immediateService = Executors.newFixedThreadPool(5);
for (Map.Entry<Future<?>, Runnable> entry : scheduledFutures.entrySet()) {
Future<?> future = entry.getKey();
Runnable task = entry.getValue();
if (!future.isDone()) {
if (future.cancel(false)) {
immediateService.submit(task);
}
}
}
immediateService.shutdown();
}
//...
}
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.