@Override protected <V> ManagedFutureTask<V> getNewTaskFor(Runnable r, V result) { return new ManagedFutureTask<>(this, r, result); }
@Override boolean cancelTask() { if (task != null) { return task.cancel(true); } return false; }
public ManagedFutureTask( AbstractManagedExecutorService executor, Runnable runnable, V result) { super(runnable, result); this.task = runnable; this.executor = executor; this.taskListener = getManagedTaskListener(task); this.isContextualCallback = isTaskContextualCallback(task) || executor.isContextualCallback(); captureContext(executor); }
@Override protected void done() { // for calling taskDone for cancelled tasks super.done(); if (taskDoneCallback != null) { taskDoneCallback.taskDone(this); } if (taskListener != null && isCancelled()) { try { if (isContextualCallback) { setupContext(); } taskListener.taskDone(this, executor.getExecutorForTaskListener(), task, new CancellationException()); } finally { if (isContextualCallback) { resetContext(); } } } }
public void submitted() { if (taskListener != null) { try { if (isContextualCallback) { setupContext(); } taskListener.taskSubmitted(this, executor.getExecutorForTaskListener(), task); } finally { if (isContextualCallback) { resetContext(); } } } }
@Override protected void afterExecute(Runnable r, Throwable t) { super.afterExecute(r, t); ManagedFutureTask task = (ManagedFutureTask) r; try { task.done(t); } finally { task.resetContext(); // Kill thread if thread older than threadLifeTime if (threadLifeTime > 0) { Thread thread = Thread.currentThread(); if (thread instanceof AbstractManagedThread) { long threadStartTime = ((AbstractManagedThread)thread).getThreadStartTime(); if ((System.currentTimeMillis() - threadStartTime)/1000 > threadLifeTime) { throw new ThreadExpiredException(); } } } } }
/** * Overrides FutureTask version so as to reset/requeue if periodic. */ @Override public void run() { boolean periodic = isPeriodic(); if (!canRunInCurrentRunState(periodic)) { cancel(false); } else if (!periodic) { ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask.super.run(); } else if (ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask.super.runAndReset()) { setNextRunTime(); reExecutePeriodic(outerTask); } } }
@Override public String getTaskIdentityName() { if (task != null) { return task.getTaskIdentityName(); } return "null"; }
@Override public boolean cancel(boolean mayInterruptIfRunning) { boolean result = super.cancel(mayInterruptIfRunning); if (result && taskListener != null) { try { if (isContextualCallback) { setupContext(); } taskListener.taskAborted(this, executor.getExecutorForTaskListener(), task, new CancellationException()); } finally { if (isContextualCallback) { resetContext(); } } } return result; }
public ManagedFutureTask( AbstractManagedExecutorService executor, Callable callable) { super(callable); this.task = callable; this.executor = executor; this.taskListener = getManagedTaskListener(task); this.isContextualCallback = isTaskContextualCallback(task) || executor.isContextualCallback(); captureContext (executor); }
@Override public List<Runnable> shutdownNow() { List<Runnable> pendingTasks = getThreadPoolExecutor().shutdownNow(); for (Runnable r: pendingTasks) { if (r instanceof ManagedFutureTask) { ((ManagedFutureTask) r).cancel(true); } } return pendingTasks; }
@Override protected ManagedFutureTask getNewTaskFor(Callable callable) { return new ManagedFutureTask(this, callable); }
@Override public boolean cancel(boolean mayInterruptIfRunning) { super.cancel(mayInterruptIfRunning); // cancel the next scheduled task return getCurrentFuture().cancel(mayInterruptIfRunning); }
@Override public boolean cancel(boolean mayInterruptIfRunning) { boolean cancelled = super.cancel(mayInterruptIfRunning); if (cancelled && getRemoveOnCancelPolicy() && heapIndex >= 0) { remove(this); } return cancelled; }