public void executeManagedTask(ManagedFutureTask task) { if (task instanceof ManagedScheduledFutureTask) { delayedExecute((ManagedScheduledFutureTask)task); } else { // should not happen schedule(task.executor, task, null, 0L, TimeUnit.NANOSECONDS); } }
@Override protected void executeManagedFutureTask(ManagedFutureTask task) { // task.submitted() will be called from threadPoolExecutor.delayExecute() threadPoolExecutor.executeManagedTask(task); }
@Override public long getCompletedTaskCount() { return threadPoolExecutor.getCompletedTaskCount(); } }
/** * Same as prestartCoreThread except arranges that at least one * thread is started even if corePoolSize is 0. */ void ensurePrestart() { if (getCorePoolSize() == 0) { setCorePoolSize(1); } prestartCoreThread(); }
public void setThreadLifeTime(long threadLifeTime) { this.threadLifeTime = threadLifeTime; if (threadLifeTime > 0) { // do not set allowCoreThreadTimeOut(true); as warned by // ScheduledThreadPoolExecutor javadoc long keepAliveTime = getKeepAliveTime(TimeUnit.SECONDS); if (keepAliveTime == 0 || threadLifeTime < keepAliveTime) { setKeepAliveTime(threadLifeTime, TimeUnit.SECONDS); } } }
/** * Main execution method for delayed or periodic tasks. If pool * is shut down, rejects the task. Otherwise adds task to queue * and starts a thread, if necessary, to run it. (We cannot * prestart the thread to run the task because the task (probably) * shouldn't be run yet,) If the pool is shut down while the task * is being added, cancel and remove it if required by state and * run-after-shutdown parameters. * * @param task the task */ private void delayedExecute(ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask<?> task) { task.submitted(); if (isShutdown()) reject(task); else { super.getQueue().add(task); if (isShutdown() && !canRunInCurrentRunState(task.isPeriodic()) && remove(task)) task.cancel(false); else ensurePrestart(); } }
public <V> ScheduledFuture<V> schedule(AbstractManagedExecutorService executor, Callable<V> callable, long delay, TimeUnit unit) { if (callable == null || unit == null) throw new NullPointerException(); ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask<V> t = new ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask<>( executor, callable, triggerTime(delay, unit)); delayedExecute(t); return t; }
/** * Requeues a periodic task unless current run state precludes it. * Same idea as delayedExecute except drops task rather than rejecting. * * @param task the task */ void reExecutePeriodic(RunnableScheduledFuture<?> task) { if (canRunInCurrentRunState(true)) { super.getQueue().add(task); if (!canRunInCurrentRunState(true) && remove(task)) task.cancel(false); else ensurePrestart(); } }
public ManagedScheduledExecutorServiceImpl(String name, ManagedThreadFactoryImpl managedThreadFactory, long hungTaskThreshold, boolean longRunningTasks, int corePoolSize, long keepAliveTime, TimeUnit keepAliveTimeUnit, long threadLifeTime, ContextServiceImpl contextService, RejectPolicy rejectPolicy) { super(name, managedThreadFactory, hungTaskThreshold, longRunningTasks, contextService, contextService != null? contextService.getContextSetupProvider(): null, rejectPolicy); threadPoolExecutor = new ManagedScheduledThreadPoolExecutor(corePoolSize, this.managedThreadFactory); threadPoolExecutor.setKeepAliveTime(keepAliveTime, keepAliveTimeUnit); threadPoolExecutor.setThreadLifeTime(threadLifeTime); adapter = new ManagedScheduledExecutorServiceAdapter(this); }
@Override public boolean cancel(boolean mayInterruptIfRunning) { boolean cancelled = super.cancel(mayInterruptIfRunning); if (cancelled && getRemoveOnCancelPolicy() && heapIndex >= 0) { remove(this); } return cancelled; }
/** * 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); } } }
/** * Invokes the rejected execution handler for the given command. * Package-protected for use by ScheduledThreadPoolExecutor. */ final void reject(Runnable command) { RejectedExecutionHandler handler = getRejectedExecutionHandler(); if (handler != null) { handler.rejectedExecution(command, this); } }
public <V> ScheduledFuture<V> schedule(AbstractManagedExecutorService executor, Runnable command, V result, long delay, TimeUnit unit) { if (command == null || unit == null) { throw new NullPointerException(); } ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask<V> t = new ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask<>( executor, command, result, triggerTime(delay, unit)); delayedExecute(t); return t; }
public ScheduledFuture<?> scheduleWithFixedDelay(AbstractManagedExecutorService executor, Runnable command, long initialDelay, long delay, TimeUnit unit) { if (command == null || unit == null) throw new NullPointerException(); if (delay <= 0) throw new IllegalArgumentException(); ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask<Void> t = new ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask<>( executor, command, null, triggerTime(initialDelay, unit), unit.toNanos(-delay)); delayedExecute(t); return t; }
public ScheduledFuture<?> scheduleAtFixedRate(AbstractManagedExecutorService executor, Runnable command, long initialDelay, long period, TimeUnit unit) { if (command == null || unit == null) throw new NullPointerException(); if (period <= 0) throw new IllegalArgumentException(); ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask<Void> t = new ManagedScheduledThreadPoolExecutor.ManagedScheduledFutureTask<>( executor, command, null, triggerTime(initialDelay, unit), unit.toNanos(period)); delayedExecute(t); return t; }