History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/util/concurrent/ScheduledThreadPoolExecutor.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/util/concurrent/ScheduledThreadPoolExecutor.java+1277−0
@@ -0,0 +1,1277 @@
1/*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25/*
26 * This file is available under and governed by the GNU General Public
27 * License version 2 only, as published by the Free Software Foundation.
28 * However, the following notice accompanied the original version of this
29 * file:
30 *
31 * Written by Doug Lea with assistance from members of JCP JSR-166
32 * Expert Group and released to the public domain, as explained at
33 * http://creativecommons.org/publicdomain/zero/1.0/
34 */
35
36package java.util.concurrent;
37import java.util.concurrent.atomic.*;
38import java.util.concurrent.locks.*;
39import java.util.*;
40
41/**
42 * A {@link ThreadPoolExecutor} that can additionally schedule
43 * commands to run after a given delay, or to execute
44 * periodically. This class is preferable to {@link java.util.Timer}
45 * when multiple worker threads are needed, or when the additional
46 * flexibility or capabilities of {@link ThreadPoolExecutor} (which
47 * this class extends) are required.
48 *
49 * <p>Delayed tasks execute no sooner than they are enabled, but
50 * without any real-time guarantees about when, after they are
51 * enabled, they will commence. Tasks scheduled for exactly the same
52 * execution time are enabled in first-in-first-out (FIFO) order of
53 * submission.
54 *
55 * <p>When a submitted task is cancelled before it is run, execution
56 * is suppressed. By default, such a cancelled task is not
57 * automatically removed from the work queue until its delay
58 * elapses. While this enables further inspection and monitoring, it
59 * may also cause unbounded retention of cancelled tasks. To avoid
60 * this, set {@link #setRemoveOnCancelPolicy} to {@code true}, which
61 * causes tasks to be immediately removed from the work queue at
62 * time of cancellation.
63 *
64 * <p>Successive executions of a task scheduled via
65 * {@code scheduleAtFixedRate} or
66 * {@code scheduleWithFixedDelay} do not overlap. While different
67 * executions may be performed by different threads, the effects of
68 * prior executions <a
69 * href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
70 * those of subsequent ones.
71 *
72 * <p>While this class inherits from {@link ThreadPoolExecutor}, a few
73 * of the inherited tuning methods are not useful for it. In
74 * particular, because it acts as a fixed-sized pool using
75 * {@code corePoolSize} threads and an unbounded queue, adjustments
76 * to {@code maximumPoolSize} have no useful effect. Additionally, it
77 * is almost never a good idea to set {@code corePoolSize} to zero or
78 * use {@code allowCoreThreadTimeOut} because this may leave the pool
79 * without threads to handle tasks once they become eligible to run.
80 *
81 * <p><b>Extension notes:</b> This class overrides the
82 * {@link ThreadPoolExecutor#execute execute} and
83 * {@link AbstractExecutorService#submit(Runnable) submit}
84 * methods to generate internal {@link ScheduledFuture} objects to
85 * control per-task delays and scheduling. To preserve
86 * functionality, any further overrides of these methods in
87 * subclasses must invoke superclass versions, which effectively
88 * disables additional task customization. However, this class
89 * provides alternative protected extension method
90 * {@code decorateTask} (one version each for {@code Runnable} and
91 * {@code Callable}) that can be used to customize the concrete task
92 * types used to execute commands entered via {@code execute},
93 * {@code submit}, {@code schedule}, {@code scheduleAtFixedRate},
94 * and {@code scheduleWithFixedDelay}. By default, a
95 * {@code ScheduledThreadPoolExecutor} uses a task type extending
96 * {@link FutureTask}. However, this may be modified or replaced using
97 * subclasses of the form:
98 *
99 * <pre> {@code
100 * public class CustomScheduledExecutor extends ScheduledThreadPoolExecutor {
101 *
102 * static class CustomTask<V> implements RunnableScheduledFuture<V> { ... }
103 *
104 * protected <V> RunnableScheduledFuture<V> decorateTask(
105 * Runnable r, RunnableScheduledFuture<V> task) {
106 * return new CustomTask<V>(r, task);
107 * }
108 *
109 * protected <V> RunnableScheduledFuture<V> decorateTask(
110 * Callable<V> c, RunnableScheduledFuture<V> task) {
111 * return new CustomTask<V>(c, task);
112 * }
113 * // ... add constructors, etc.
114 * }}</pre>
115 *
116 * @since 1.5
117 * @author Doug Lea
118 */
119public class ScheduledThreadPoolExecutor
120 extends ThreadPoolExecutor
121 implements ScheduledExecutorService {
122
123 /*
124 * This class specializes ThreadPoolExecutor implementation by
125 *
126 * 1. Using a custom task type, ScheduledFutureTask for
127 * tasks, even those that don't require scheduling (i.e.,
128 * those submitted using ExecutorService execute, not
129 * ScheduledExecutorService methods) which are treated as
130 * delayed tasks with a delay of zero.
131 *
132 * 2. Using a custom queue (DelayedWorkQueue), a variant of
133 * unbounded DelayQueue. The lack of capacity constraint and
134 * the fact that corePoolSize and maximumPoolSize are
135 * effectively identical simplifies some execution mechanics
136 * (see delayedExecute) compared to ThreadPoolExecutor.
137 *
138 * 3. Supporting optional run-after-shutdown parameters, which
139 * leads to overrides of shutdown methods to remove and cancel
140 * tasks that should NOT be run after shutdown, as well as
141 * different recheck logic when task (re)submission overlaps
142 * with a shutdown.
143 *
144 * 4. Task decoration methods to allow interception and
145 * instrumentation, which are needed because subclasses cannot
146 * otherwise override submit methods to get this effect. These
147 * don't have any impact on pool control logic though.
148 */
149
150 /**
151 * False if should cancel/suppress periodic tasks on shutdown.
152 */
153 private volatile boolean continueExistingPeriodicTasksAfterShutdown;
154
155 /**
156 * False if should cancel non-periodic tasks on shutdown.
157 */
158 private volatile boolean executeExistingDelayedTasksAfterShutdown = true;
159
160 /**
161 * True if ScheduledFutureTask.cancel should remove from queue
162 */
163 private volatile boolean removeOnCancel = false;
164
165 /**
166 * Sequence number to break scheduling ties, and in turn to
167 * guarantee FIFO order among tied entries.
168 */
169 private static final AtomicLong sequencer = new AtomicLong(0);
170
171 /**
172 * Returns current nanosecond time.
173 */
174 final long now() {
175 return System.nanoTime();
176 }
177
178 private class ScheduledFutureTask<V>
179 extends FutureTask<V> implements RunnableScheduledFuture<V> {
180
181 /** Sequence number to break ties FIFO */
182 private final long sequenceNumber;
183
184 /** The time the task is enabled to execute in nanoTime units */
185 private long time;
186
187 /**
188 * Period in nanoseconds for repeating tasks. A positive
189 * value indicates fixed-rate execution. A negative value
190 * indicates fixed-delay execution. A value of 0 indicates a
191 * non-repeating task.
192 */
193 private final long period;
194
195 /** The actual task to be re-enqueued by reExecutePeriodic */
196 RunnableScheduledFuture<V> outerTask = this;
197
198 /**
199 * Index into delay queue, to support faster cancellation.
200 */
201 int heapIndex;
202
203 /**
204 * Creates a one-shot action with given nanoTime-based trigger time.
205 */
206 ScheduledFutureTask(Runnable r, V result, long ns) {
207 super(r, result);
208 this.time = ns;
209 this.period = 0;
210 this.sequenceNumber = sequencer.getAndIncrement();
211 }
212
213 /**
214 * Creates a periodic action with given nano time and period.
215 */
216 ScheduledFutureTask(Runnable r, V result, long ns, long period) {
217 super(r, result);
218 this.time = ns;
219 this.period = period;
220 this.sequenceNumber = sequencer.getAndIncrement();
221 }
222
223 /**
224 * Creates a one-shot action with given nanoTime-based trigger.
225 */
226 ScheduledFutureTask(Callable<V> callable, long ns) {
227 super(callable);
228 this.time = ns;
229 this.period = 0;
230 this.sequenceNumber = sequencer.getAndIncrement();
231 }
232
233 public long getDelay(TimeUnit unit) {
234 return unit.convert(time - now(), TimeUnit.NANOSECONDS);
235 }
236
237 public int compareTo(Delayed other) {
238 if (other == this) // compare zero ONLY if same object
239 return 0;
240 if (other instanceof ScheduledFutureTask) {
241 ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
242 long diff = time - x.time;
243 if (diff < 0)
244 return -1;
245 else if (diff > 0)
246 return 1;
247 else if (sequenceNumber < x.sequenceNumber)
248 return -1;
249 else
250 return 1;
251 }
252 long d = (getDelay(TimeUnit.NANOSECONDS) -
253 other.getDelay(TimeUnit.NANOSECONDS));
254 return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
255 }
256
257 /**
258 * Returns true if this is a periodic (not a one-shot) action.
259 *
260 * @return true if periodic
261 */
262 public boolean isPeriodic() {
263 return period != 0;
264 }
265
266 /**
267 * Sets the next time to run for a periodic task.
268 */
269 private void setNextRunTime() {
270 long p = period;
271 if (p > 0)
272 time += p;
273 else
274 time = triggerTime(-p);
275 }
276
277 public boolean cancel(boolean mayInterruptIfRunning) {
278 boolean cancelled = super.cancel(mayInterruptIfRunning);
279 if (cancelled && removeOnCancel && heapIndex >= 0)
280 remove(this);
281 return cancelled;
282 }
283
284 /**
285 * Overrides FutureTask version so as to reset/requeue if periodic.
286 */
287 public void run() {
288 boolean periodic = isPeriodic();
289 if (!canRunInCurrentRunState(periodic))
290 cancel(false);
291 else if (!periodic)
292 ScheduledFutureTask.super.run();
293 else if (ScheduledFutureTask.super.runAndReset()) {
294 setNextRunTime();
295 reExecutePeriodic(outerTask);
296 }
297 }
298 }
299
300 /**
301 * Returns true if can run a task given current run state
302 * and run-after-shutdown parameters.
303 *
304 * @param periodic true if this task periodic, false if delayed
305 */
306 boolean canRunInCurrentRunState(boolean periodic) {
307 return isRunningOrShutdown(periodic ?
308 continueExistingPeriodicTasksAfterShutdown :
309 executeExistingDelayedTasksAfterShutdown);
310 }
311
312 /**
313 * Main execution method for delayed or periodic tasks. If pool
314 * is shut down, rejects the task. Otherwise adds task to queue
315 * and starts a thread, if necessary, to run it. (We cannot
316 * prestart the thread to run the task because the task (probably)
317 * shouldn't be run yet,) If the pool is shut down while the task
318 * is being added, cancel and remove it if required by state and
319 * run-after-shutdown parameters.
320 *
321 * @param task the task
322 */
323 private void delayedExecute(RunnableScheduledFuture<?> task) {
324 if (isShutdown())
325 reject(task);
326 else {
327 super.getQueue().add(task);
328 if (isShutdown() &&
329 !canRunInCurrentRunState(task.isPeriodic()) &&
330 remove(task))
331 task.cancel(false);
332 else
333 prestartCoreThread();
334 }
335 }
336
337 /**
338 * Requeues a periodic task unless current run state precludes it.
339 * Same idea as delayedExecute except drops task rather than rejecting.
340 *
341 * @param task the task
342 */
343 void reExecutePeriodic(RunnableScheduledFuture<?> task) {
344 if (canRunInCurrentRunState(true)) {
345 super.getQueue().add(task);
346 if (!canRunInCurrentRunState(true) && remove(task))
347 task.cancel(false);
348 else
349 prestartCoreThread();
350 }
351 }
352
353 /**
354 * Cancels and clears the queue of all tasks that should not be run
355 * due to shutdown policy. Invoked within super.shutdown.
356 */
357 @Override void onShutdown() {
358 BlockingQueue<Runnable> q = super.getQueue();
359 boolean keepDelayed =
360 getExecuteExistingDelayedTasksAfterShutdownPolicy();
361 boolean keepPeriodic =
362 getContinueExistingPeriodicTasksAfterShutdownPolicy();
363 if (!keepDelayed && !keepPeriodic) {
364 for (Object e : q.toArray())
365 if (e instanceof RunnableScheduledFuture<?>)
366 ((RunnableScheduledFuture<?>) e).cancel(false);
367 q.clear();
368 }
369 else {
370 // Traverse snapshot to avoid iterator exceptions
371 for (Object e : q.toArray()) {
372 if (e instanceof RunnableScheduledFuture) {
373 RunnableScheduledFuture<?> t =
374 (RunnableScheduledFuture<?>)e;
375 if ((t.isPeriodic() ? !keepPeriodic : !keepDelayed) ||
376 t.isCancelled()) { // also remove if already cancelled
377 if (q.remove(t))
378 t.cancel(false);
379 }
380 }
381 }
382 }
383 tryTerminate();
384 }
385
386 /**
387 * Modifies or replaces the task used to execute a runnable.
388 * This method can be used to override the concrete
389 * class used for managing internal tasks.
390 * The default implementation simply returns the given task.
391 *
392 * @param runnable the submitted Runnable
393 * @param task the task created to execute the runnable
394 * @return a task that can execute the runnable
395 * @since 1.6
396 */
397 protected <V> RunnableScheduledFuture<V> decorateTask(
398 Runnable runnable, RunnableScheduledFuture<V> task) {
399 return task;
400 }
401
402 /**
403 * Modifies or replaces the task used to execute a callable.
404 * This method can be used to override the concrete
405 * class used for managing internal tasks.
406 * The default implementation simply returns the given task.
407 *
408 * @param callable the submitted Callable
409 * @param task the task created to execute the callable
410 * @return a task that can execute the callable
411 * @since 1.6
412 */
413 protected <V> RunnableScheduledFuture<V> decorateTask(
414 Callable<V> callable, RunnableScheduledFuture<V> task) {
415 return task;
416 }
417
418 /**
419 * Creates a new {@code ScheduledThreadPoolExecutor} with the
420 * given core pool size.
421 *
422 * @param corePoolSize the number of threads to keep in the pool, even
423 * if they are idle, unless {@code allowCoreThreadTimeOut} is set
424 * @throws IllegalArgumentException if {@code corePoolSize < 0}
425 */
426 public ScheduledThreadPoolExecutor(int corePoolSize) {
427 super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
428 new DelayedWorkQueue());
429 }
430
431 /**
432 * Creates a new {@code ScheduledThreadPoolExecutor} with the
433 * given initial parameters.
434 *
435 * @param corePoolSize the number of threads to keep in the pool, even
436 * if they are idle, unless {@code allowCoreThreadTimeOut} is set
437 * @param threadFactory the factory to use when the executor
438 * creates a new thread
439 * @throws IllegalArgumentException if {@code corePoolSize < 0}
440 * @throws NullPointerException if {@code threadFactory} is null
441 */
442 public ScheduledThreadPoolExecutor(int corePoolSize,
443 ThreadFactory threadFactory) {
444 super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
445 new DelayedWorkQueue(), threadFactory);
446 }
447
448 /**
449 * Creates a new ScheduledThreadPoolExecutor with the given
450 * initial parameters.
451 *
452 * @param corePoolSize the number of threads to keep in the pool, even
453 * if they are idle, unless {@code allowCoreThreadTimeOut} is set
454 * @param handler the handler to use when execution is blocked
455 * because the thread bounds and queue capacities are reached
456 * @throws IllegalArgumentException if {@code corePoolSize < 0}
457 * @throws NullPointerException if {@code handler} is null
458 */
459 public ScheduledThreadPoolExecutor(int corePoolSize,
460 RejectedExecutionHandler handler) {
461 super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
462 new DelayedWorkQueue(), handler);
463 }
464
465 /**
466 * Creates a new ScheduledThreadPoolExecutor with the given
467 * initial parameters.
468 *
469 * @param corePoolSize the number of threads to keep in the pool, even
470 * if they are idle, unless {@code allowCoreThreadTimeOut} is set
471 * @param threadFactory the factory to use when the executor
472 * creates a new thread
473 * @param handler the handler to use when execution is blocked
474 * because the thread bounds and queue capacities are reached
475 * @throws IllegalArgumentException if {@code corePoolSize < 0}
476 * @throws NullPointerException if {@code threadFactory} or
477 * {@code handler} is null
478 */
479 public ScheduledThreadPoolExecutor(int corePoolSize,
480 ThreadFactory threadFactory,
481 RejectedExecutionHandler handler) {
482 super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
483 new DelayedWorkQueue(), threadFactory, handler);
484 }
485
486 /**
487 * Returns the trigger time of a delayed action.
488 */
489 private long triggerTime(long delay, TimeUnit unit) {
490 return triggerTime(unit.toNanos((delay < 0) ? 0 : delay));
491 }
492
493 /**
494 * Returns the trigger time of a delayed action.
495 */
496 long triggerTime(long delay) {
497 return now() +
498 ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
499 }
500
501 /**
502 * Constrains the values of all delays in the queue to be within
503 * Long.MAX_VALUE of each other, to avoid overflow in compareTo.
504 * This may occur if a task is eligible to be dequeued, but has
505 * not yet been, while some other task is added with a delay of
506 * Long.MAX_VALUE.
507 */
508 private long overflowFree(long delay) {
509 Delayed head = (Delayed) super.getQueue().peek();
510 if (head != null) {
511 long headDelay = head.getDelay(TimeUnit.NANOSECONDS);
512 if (headDelay < 0 && (delay - headDelay < 0))
513 delay = Long.MAX_VALUE + headDelay;
514 }
515 return delay;
516 }
517
518 /**
519 * @throws RejectedExecutionException {@inheritDoc}
520 * @throws NullPointerException {@inheritDoc}
521 */
522 public ScheduledFuture<?> schedule(Runnable command,
523 long delay,
524 TimeUnit unit) {
525 if (command == null || unit == null)
526 throw new NullPointerException();
527 RunnableScheduledFuture<?> t = decorateTask(command,
528 new ScheduledFutureTask<Void>(command, null,
529 triggerTime(delay, unit)));
530 delayedExecute(t);
531 return t;
532 }
533
534 /**
535 * @throws RejectedExecutionException {@inheritDoc}
536 * @throws NullPointerException {@inheritDoc}
537 */
538 public <V> ScheduledFuture<V> schedule(Callable<V> callable,
539 long delay,
540 TimeUnit unit) {
541 if (callable == null || unit == null)
542 throw new NullPointerException();
543 RunnableScheduledFuture<V> t = decorateTask(callable,
544 new ScheduledFutureTask<V>(callable,
545 triggerTime(delay, unit)));
546 delayedExecute(t);
547 return t;
548 }
549
550 /**
551 * @throws RejectedExecutionException {@inheritDoc}
552 * @throws NullPointerException {@inheritDoc}
553 * @throws IllegalArgumentException {@inheritDoc}
554 */
555 public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
556 long initialDelay,
557 long period,
558 TimeUnit unit) {
559 if (command == null || unit == null)
560 throw new NullPointerException();
561 if (period <= 0)
562 throw new IllegalArgumentException();
563 ScheduledFutureTask<Void> sft =
564 new ScheduledFutureTask<Void>(command,
565 null,
566 triggerTime(initialDelay, unit),
567 unit.toNanos(period));
568 RunnableScheduledFuture<Void> t = decorateTask(command, sft);
569 sft.outerTask = t;
570 delayedExecute(t);
571 return t;
572 }
573
574 /**
575 * @throws RejectedExecutionException {@inheritDoc}
576 * @throws NullPointerException {@inheritDoc}
577 * @throws IllegalArgumentException {@inheritDoc}
578 */
579 public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
580 long initialDelay,
581 long delay,
582 TimeUnit unit) {
583 if (command == null || unit == null)
584 throw new NullPointerException();
585 if (delay <= 0)
586 throw new IllegalArgumentException();
587 ScheduledFutureTask<Void> sft =
588 new ScheduledFutureTask<Void>(command,
589 null,
590 triggerTime(initialDelay, unit),
591 unit.toNanos(-delay));
592 RunnableScheduledFuture<Void> t = decorateTask(command, sft);
593 sft.outerTask = t;
594 delayedExecute(t);
595 return t;
596 }
597
598 /**
599 * Executes {@code command} with zero required delay.
600 * This has effect equivalent to
601 * {@link #schedule(Runnable,long,TimeUnit) schedule(command, 0, anyUnit)}.
602 * Note that inspections of the queue and of the list returned by
603 * {@code shutdownNow} will access the zero-delayed
604 * {@link ScheduledFuture}, not the {@code command} itself.
605 *
606 * <p>A consequence of the use of {@code ScheduledFuture} objects is
607 * that {@link ThreadPoolExecutor#afterExecute afterExecute} is always
608 * called with a null second {@code Throwable} argument, even if the
609 * {@code command} terminated abruptly. Instead, the {@code Throwable}
610 * thrown by such a task can be obtained via {@link Future#get}.
611 *
612 * @throws RejectedExecutionException at discretion of
613 * {@code RejectedExecutionHandler}, if the task
614 * cannot be accepted for execution because the
615 * executor has been shut down
616 * @throws NullPointerException {@inheritDoc}
617 */
618 public void execute(Runnable command) {
619 schedule(command, 0, TimeUnit.NANOSECONDS);
620 }
621
622 // Override AbstractExecutorService methods
623
624 /**
625 * @throws RejectedExecutionException {@inheritDoc}
626 * @throws NullPointerException {@inheritDoc}
627 */
628 public Future<?> submit(Runnable task) {
629 return schedule(task, 0, TimeUnit.NANOSECONDS);
630 }
631
632 /**
633 * @throws RejectedExecutionException {@inheritDoc}
634 * @throws NullPointerException {@inheritDoc}
635 */
636 public <T> Future<T> submit(Runnable task, T result) {
637 return schedule(Executors.callable(task, result),
638 0, TimeUnit.NANOSECONDS);
639 }
640
641 /**
642 * @throws RejectedExecutionException {@inheritDoc}
643 * @throws NullPointerException {@inheritDoc}
644 */
645 public <T> Future<T> submit(Callable<T> task) {
646 return schedule(task, 0, TimeUnit.NANOSECONDS);
647 }
648
649 /**
650 * Sets the policy on whether to continue executing existing
651 * periodic tasks even when this executor has been {@code shutdown}.
652 * In this case, these tasks will only terminate upon
653 * {@code shutdownNow} or after setting the policy to
654 * {@code false} when already shutdown.
655 * This value is by default {@code false}.
656 *
657 * @param value if {@code true}, continue after shutdown, else don't.
658 * @see #getContinueExistingPeriodicTasksAfterShutdownPolicy
659 */
660 public void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value) {
661 continueExistingPeriodicTasksAfterShutdown = value;
662 if (!value && isShutdown())
663 onShutdown();
664 }
665
666 /**
667 * Gets the policy on whether to continue executing existing
668 * periodic tasks even when this executor has been {@code shutdown}.
669 * In this case, these tasks will only terminate upon
670 * {@code shutdownNow} or after setting the policy to
671 * {@code false} when already shutdown.
672 * This value is by default {@code false}.
673 *
674 * @return {@code true} if will continue after shutdown
675 * @see #setContinueExistingPeriodicTasksAfterShutdownPolicy
676 */
677 public boolean getContinueExistingPeriodicTasksAfterShutdownPolicy() {
678 return continueExistingPeriodicTasksAfterShutdown;
679 }
680
681 /**
682 * Sets the policy on whether to execute existing delayed
683 * tasks even when this executor has been {@code shutdown}.
684 * In this case, these tasks will only terminate upon
685 * {@code shutdownNow}, or after setting the policy to
686 * {@code false} when already shutdown.
687 * This value is by default {@code true}.
688 *
689 * @param value if {@code true}, execute after shutdown, else don't.
690 * @see #getExecuteExistingDelayedTasksAfterShutdownPolicy
691 */
692 public void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value) {
693 executeExistingDelayedTasksAfterShutdown = value;
694 if (!value && isShutdown())
695 onShutdown();
696 }
697
698 /**
699 * Gets the policy on whether to execute existing delayed
700 * tasks even when this executor has been {@code shutdown}.
701 * In this case, these tasks will only terminate upon
702 * {@code shutdownNow}, or after setting the policy to
703 * {@code false} when already shutdown.
704 * This value is by default {@code true}.
705 *
706 * @return {@code true} if will execute after shutdown
707 * @see #setExecuteExistingDelayedTasksAfterShutdownPolicy
708 */
709 public boolean getExecuteExistingDelayedTasksAfterShutdownPolicy() {
710 return executeExistingDelayedTasksAfterShutdown;
711 }
712
713 /**
714 * Sets the policy on whether cancelled tasks should be immediately
715 * removed from the work queue at time of cancellation. This value is
716 * by default {@code false}.
717 *
718 * @param value if {@code true}, remove on cancellation, else don't
719 * @see #getRemoveOnCancelPolicy
720 * @since 1.7
721 */
722 public void setRemoveOnCancelPolicy(boolean value) {
723 removeOnCancel = value;
724 }
725
726 /**
727 * Gets the policy on whether cancelled tasks should be immediately
728 * removed from the work queue at time of cancellation. This value is
729 * by default {@code false}.
730 *
731 * @return {@code true} if cancelled tasks are immediately removed
732 * from the queue
733 * @see #setRemoveOnCancelPolicy
734 * @since 1.7
735 */
736 public boolean getRemoveOnCancelPolicy() {
737 return removeOnCancel;
738 }
739
740 /**
741 * Initiates an orderly shutdown in which previously submitted
742 * tasks are executed, but no new tasks will be accepted.
743 * Invocation has no additional effect if already shut down.
744 *
745 * <p>This method does not wait for previously submitted tasks to
746 * complete execution. Use {@link #awaitTermination awaitTermination}
747 * to do that.
748 *
749 * <p>If the {@code ExecuteExistingDelayedTasksAfterShutdownPolicy}
750 * has been set {@code false}, existing delayed tasks whose delays
751 * have not yet elapsed are cancelled. And unless the {@code
752 * ContinueExistingPeriodicTasksAfterShutdownPolicy} has been set
753 * {@code true}, future executions of existing periodic tasks will
754 * be cancelled.
755 *
756 * @throws SecurityException {@inheritDoc}
757 */
758 public void shutdown() {
759 super.shutdown();
760 }
761
762 /**
763 * Attempts to stop all actively executing tasks, halts the
764 * processing of waiting tasks, and returns a list of the tasks
765 * that were awaiting execution.
766 *
767 * <p>This method does not wait for actively executing tasks to
768 * terminate. Use {@link #awaitTermination awaitTermination} to
769 * do that.
770 *
771 * <p>There are no guarantees beyond best-effort attempts to stop
772 * processing actively executing tasks. This implementation
773 * cancels tasks via {@link Thread#interrupt}, so any task that
774 * fails to respond to interrupts may never terminate.
775 *
776 * @return list of tasks that never commenced execution.
777 * Each element of this list is a {@link ScheduledFuture},
778 * including those tasks submitted using {@code execute},
779 * which are for scheduling purposes used as the basis of a
780 * zero-delay {@code ScheduledFuture}.
781 * @throws SecurityException {@inheritDoc}
782 */
783 public List<Runnable> shutdownNow() {
784 return super.shutdownNow();
785 }
786
787 /**
788 * Returns the task queue used by this executor. Each element of
789 * this queue is a {@link ScheduledFuture}, including those
790 * tasks submitted using {@code execute} which are for scheduling
791 * purposes used as the basis of a zero-delay
792 * {@code ScheduledFuture}. Iteration over this queue is
793 * <em>not</em> guaranteed to traverse tasks in the order in
794 * which they will execute.
795 *
796 * @return the task queue
797 */
798 public BlockingQueue<Runnable> getQueue() {
799 return super.getQueue();
800 }
801
802 /**
803 * Specialized delay queue. To mesh with TPE declarations, this
804 * class must be declared as a BlockingQueue<Runnable> even though
805 * it can only hold RunnableScheduledFutures.
806 */
807 static class DelayedWorkQueue extends AbstractQueue<Runnable>
808 implements BlockingQueue<Runnable> {
809
810 /*
811 * A DelayedWorkQueue is based on a heap-based data structure
812 * like those in DelayQueue and PriorityQueue, except that
813 * every ScheduledFutureTask also records its index into the
814 * heap array. This eliminates the need to find a task upon
815 * cancellation, greatly speeding up removal (down from O(n)
816 * to O(log n)), and reducing garbage retention that would
817 * otherwise occur by waiting for the element to rise to top
818 * before clearing. But because the queue may also hold
819 * RunnableScheduledFutures that are not ScheduledFutureTasks,
820 * we are not guaranteed to have such indices available, in
821 * which case we fall back to linear search. (We expect that
822 * most tasks will not be decorated, and that the faster cases
823 * will be much more common.)
824 *
825 * All heap operations must record index changes -- mainly
826 * within siftUp and siftDown. Upon removal, a task's
827 * heapIndex is set to -1. Note that ScheduledFutureTasks can
828 * appear at most once in the queue (this need not be true for
829 * other kinds of tasks or work queues), so are uniquely
830 * identified by heapIndex.
831 */
832
833 private static final int INITIAL_CAPACITY = 16;
834 private RunnableScheduledFuture[] queue =
835 new RunnableScheduledFuture[INITIAL_CAPACITY];
836 private final ReentrantLock lock = new ReentrantLock();
837 private int size = 0;
838
839 /**
840 * Thread designated to wait for the task at the head of the
841 * queue. This variant of the Leader-Follower pattern
842 * (http://www.cs.wustl.edu/~schmidt/POSA/POSA2/) serves to
843 * minimize unnecessary timed waiting. When a thread becomes
844 * the leader, it waits only for the next delay to elapse, but
845 * other threads await indefinitely. The leader thread must
846 * signal some other thread before returning from take() or
847 * poll(...), unless some other thread becomes leader in the
848 * interim. Whenever the head of the queue is replaced with a
849 * task with an earlier expiration time, the leader field is
850 * invalidated by being reset to null, and some waiting
851 * thread, but not necessarily the current leader, is
852 * signalled. So waiting threads must be prepared to acquire
853 * and lose leadership while waiting.
854 */
855 private Thread leader = null;
856
857 /**
858 * Condition signalled when a newer task becomes available at the
859 * head of the queue or a new thread may need to become leader.
860 */
861 private final Condition available = lock.newCondition();
862
863 /**
864 * Set f's heapIndex if it is a ScheduledFutureTask.
865 */
866 private void setIndex(RunnableScheduledFuture f, int idx) {
867 if (f instanceof ScheduledFutureTask)
868 ((ScheduledFutureTask)f).heapIndex = idx;
869 }
870
871 /**
872 * Sift element added at bottom up to its heap-ordered spot.
873 * Call only when holding lock.
874 */
875 private void siftUp(int k, RunnableScheduledFuture key) {
876 while (k > 0) {
877 int parent = (k - 1) >>> 1;
878 RunnableScheduledFuture e = queue[parent];
879 if (key.compareTo(e) >= 0)
880 break;
881 queue[k] = e;
882 setIndex(e, k);
883 k = parent;
884 }
885 queue[k] = key;
886 setIndex(key, k);
887 }
888
889 /**
890 * Sift element added at top down to its heap-ordered spot.
891 * Call only when holding lock.
892 */
893 private void siftDown(int k, RunnableScheduledFuture key) {
894 int half = size >>> 1;
895 while (k < half) {
896 int child = (k << 1) + 1;
897 RunnableScheduledFuture c = queue[child];
898 int right = child + 1;
899 if (right < size && c.compareTo(queue[right]) > 0)
900 c = queue[child = right];
901 if (key.compareTo(c) <= 0)
902 break;
903 queue[k] = c;
904 setIndex(c, k);
905 k = child;
906 }
907 queue[k] = key;
908 setIndex(key, k);
909 }
910
911 /**
912 * Resize the heap array. Call only when holding lock.
913 */
914 private void grow() {
915 int oldCapacity = queue.length;
916 int newCapacity = oldCapacity + (oldCapacity >> 1); // grow 50%
917 if (newCapacity < 0) // overflow
918 newCapacity = Integer.MAX_VALUE;
919 queue = Arrays.copyOf(queue, newCapacity);
920 }
921
922 /**
923 * Find index of given object, or -1 if absent
924 */
925 private int indexOf(Object x) {
926 if (x != null) {
927 if (x instanceof ScheduledFutureTask) {
928 int i = ((ScheduledFutureTask) x).heapIndex;
929 // Sanity check; x could conceivably be a
930 // ScheduledFutureTask from some other pool.
931 if (i >= 0 && i < size && queue[i] == x)
932 return i;
933 } else {
934 for (int i = 0; i < size; i++)
935 if (x.equals(queue[i]))
936 return i;
937 }
938 }
939 return -1;
940 }
941
942 public boolean contains(Object x) {
943 final ReentrantLock lock = this.lock;
944 lock.lock();
945 try {
946 return indexOf(x) != -1;
947 } finally {
948 lock.unlock();
949 }
950 }
951
952 public boolean remove(Object x) {
953 final ReentrantLock lock = this.lock;
954 lock.lock();
955 try {
956 int i = indexOf(x);
957 if (i < 0)
958 return false;
959
960 setIndex(queue[i], -1);
961 int s = --size;
962 RunnableScheduledFuture replacement = queue[s];
963 queue[s] = null;
964 if (s != i) {
965 siftDown(i, replacement);
966 if (queue[i] == replacement)
967 siftUp(i, replacement);
968 }
969 return true;
970 } finally {
971 lock.unlock();
972 }
973 }
974
975 public int size() {
976 final ReentrantLock lock = this.lock;
977 lock.lock();
978 try {
979 return size;
980 } finally {
981 lock.unlock();
982 }
983 }
984
985 public boolean isEmpty() {
986 return size() == 0;
987 }
988
989 public int remainingCapacity() {
990 return Integer.MAX_VALUE;
991 }
992
993 public RunnableScheduledFuture peek() {
994 final ReentrantLock lock = this.lock;
995 lock.lock();
996 try {
997 return queue[0];
998 } finally {
999 lock.unlock();
1000 }
1001 }
1002
1003 public boolean offer(Runnable x) {
1004 if (x == null)
1005 throw new NullPointerException();
1006 RunnableScheduledFuture e = (RunnableScheduledFuture)x;
1007 final ReentrantLock lock = this.lock;
1008 lock.lock();
1009 try {
1010 int i = size;
1011 if (i >= queue.length)
1012 grow();
1013 size = i + 1;
1014 if (i == 0) {
1015 queue[0] = e;
1016 setIndex(e, 0);
1017 } else {
1018 siftUp(i, e);
1019 }
1020 if (queue[0] == e) {
1021 leader = null;
1022 available.signal();
1023 }
1024 } finally {
1025 lock.unlock();
1026 }
1027 return true;
1028 }
1029
1030 public void put(Runnable e) {
1031 offer(e);
1032 }
1033
1034 public boolean add(Runnable e) {
1035 return offer(e);
1036 }
1037
1038 public boolean offer(Runnable e, long timeout, TimeUnit unit) {
1039 return offer(e);
1040 }
1041
1042 /**
1043 * Performs common bookkeeping for poll and take: Replaces
1044 * first element with last and sifts it down. Call only when
1045 * holding lock.
1046 * @param f the task to remove and return
1047 */
1048 private RunnableScheduledFuture finishPoll(RunnableScheduledFuture f) {
1049 int s = --size;
1050 RunnableScheduledFuture x = queue[s];
1051 queue[s] = null;
1052 if (s != 0)
1053 siftDown(0, x);
1054 setIndex(f, -1);
1055 return f;
1056 }
1057
1058 public RunnableScheduledFuture poll() {
1059 final ReentrantLock lock = this.lock;
1060 lock.lock();
1061 try {
1062 RunnableScheduledFuture first = queue[0];
1063 if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
1064 return null;
1065 else
1066 return finishPoll(first);
1067 } finally {
1068 lock.unlock();
1069 }
1070 }
1071
1072 public RunnableScheduledFuture take() throws InterruptedException {
1073 final ReentrantLock lock = this.lock;
1074 lock.lockInterruptibly();
1075 try {
1076 for (;;) {
1077 RunnableScheduledFuture first = queue[0];
1078 if (first == null)
1079 available.await();
1080 else {
1081 long delay = first.getDelay(TimeUnit.NANOSECONDS);
1082 if (delay <= 0)
1083 return finishPoll(first);
1084 else if (leader != null)
1085 available.await();
1086 else {
1087 Thread thisThread = Thread.currentThread();
1088 leader = thisThread;
1089 try {
1090 available.awaitNanos(delay);
1091 } finally {
1092 if (leader == thisThread)
1093 leader = null;
1094 }
1095 }
1096 }
1097 }
1098 } finally {
1099 if (leader == null && queue[0] != null)
1100 available.signal();
1101 lock.unlock();
1102 }
1103 }
1104
1105 public RunnableScheduledFuture poll(long timeout, TimeUnit unit)
1106 throws InterruptedException {
1107 long nanos = unit.toNanos(timeout);
1108 final ReentrantLock lock = this.lock;
1109 lock.lockInterruptibly();
1110 try {
1111 for (;;) {
1112 RunnableScheduledFuture first = queue[0];
1113 if (first == null) {
1114 if (nanos <= 0)
1115 return null;
1116 else
1117 nanos = available.awaitNanos(nanos);
1118 } else {
1119 long delay = first.getDelay(TimeUnit.NANOSECONDS);
1120 if (delay <= 0)
1121 return finishPoll(first);
1122 if (nanos <= 0)
1123 return null;
1124 if (nanos < delay || leader != null)
1125 nanos = available.awaitNanos(nanos);
1126 else {
1127 Thread thisThread = Thread.currentThread();
1128 leader = thisThread;
1129 try {
1130 long timeLeft = available.awaitNanos(delay);
1131 nanos -= delay - timeLeft;
1132 } finally {
1133 if (leader == thisThread)
1134 leader = null;
1135 }
1136 }
1137 }
1138 }
1139 } finally {
1140 if (leader == null && queue[0] != null)
1141 available.signal();
1142 lock.unlock();
1143 }
1144 }
1145
1146 public void clear() {
1147 final ReentrantLock lock = this.lock;
1148 lock.lock();
1149 try {
1150 for (int i = 0; i < size; i++) {
1151 RunnableScheduledFuture t = queue[i];
1152 if (t != null) {
1153 queue[i] = null;
1154 setIndex(t, -1);
1155 }
1156 }
1157 size = 0;
1158 } finally {
1159 lock.unlock();
1160 }
1161 }
1162
1163 /**
1164 * Return and remove first element only if it is expired.
1165 * Used only by drainTo. Call only when holding lock.
1166 */
1167 private RunnableScheduledFuture pollExpired() {
1168 RunnableScheduledFuture first = queue[0];
1169 if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
1170 return null;
1171 return finishPoll(first);
1172 }
1173
1174 public int drainTo(Collection<? super Runnable> c) {
1175 if (c == null)
1176 throw new NullPointerException();
1177 if (c == this)
1178 throw new IllegalArgumentException();
1179 final ReentrantLock lock = this.lock;
1180 lock.lock();
1181 try {
1182 RunnableScheduledFuture first;
1183 int n = 0;
1184 while ((first = pollExpired()) != null) {
1185 c.add(first);
1186 ++n;
1187 }
1188 return n;
1189 } finally {
1190 lock.unlock();
1191 }
1192 }
1193
1194 public int drainTo(Collection<? super Runnable> c, int maxElements) {
1195 if (c == null)
1196 throw new NullPointerException();
1197 if (c == this)
1198 throw new IllegalArgumentException();
1199 if (maxElements <= 0)
1200 return 0;
1201 final ReentrantLock lock = this.lock;
1202 lock.lock();
1203 try {
1204 RunnableScheduledFuture first;
1205 int n = 0;
1206 while (n < maxElements && (first = pollExpired()) != null) {
1207 c.add(first);
1208 ++n;
1209 }
1210 return n;
1211 } finally {
1212 lock.unlock();
1213 }
1214 }
1215
1216 public Object[] toArray() {
1217 final ReentrantLock lock = this.lock;
1218 lock.lock();
1219 try {
1220 return Arrays.copyOf(queue, size, Object[].class);
1221 } finally {
1222 lock.unlock();
1223 }
1224 }
1225
1226 @SuppressWarnings("unchecked")
1227 public <T> T[] toArray(T[] a) {
1228 final ReentrantLock lock = this.lock;
1229 lock.lock();
1230 try {
1231 if (a.length < size)
1232 return (T[]) Arrays.copyOf(queue, size, a.getClass());
1233 System.arraycopy(queue, 0, a, 0, size);
1234 if (a.length > size)
1235 a[size] = null;
1236 return a;
1237 } finally {
1238 lock.unlock();
1239 }
1240 }
1241
1242 public Iterator<Runnable> iterator() {
1243 return new Itr(Arrays.copyOf(queue, size));
1244 }
1245
1246 /**
1247 * Snapshot iterator that works off copy of underlying q array.
1248 */
1249 private class Itr implements Iterator<Runnable> {
1250 final RunnableScheduledFuture[] array;
1251 int cursor = 0; // index of next element to return
1252 int lastRet = -1; // index of last element, or -1 if no such
1253
1254 Itr(RunnableScheduledFuture[] array) {
1255 this.array = array;
1256 }
1257
1258 public boolean hasNext() {
1259 return cursor < array.length;
1260 }
1261
1262 public Runnable next() {
1263 if (cursor >= array.length)
1264 throw new NoSuchElementException();
1265 lastRet = cursor;
1266 return array[cursor++];
1267 }
1268
1269 public void remove() {
1270 if (lastRet < 0)
1271 throw new IllegalStateException();
1272 DelayedWorkQueue.this.remove(array[lastRet]);
1273 lastRet = -1;
1274 }
1275 }
1276 }
1277}