skywang12345

导航

统计
 

 

概要

在前面一章"Java多线程系列--“JUC线程池”02之 线程池原理(一)"中介绍了线程池的数据结构,本章会通过分析线程池的源码,对线程池进行说明。内容包括:
线程池示例
参考代码(基于JDK1.7.0_40)
线程池源码分析
    (一) 创建“线程池”
    (二) 添加任务到“线程池”
    (三) 关闭“线程池”

转载请注明出处:http://www.cnblogs.com/skywang12345/p/3509954.html

 

线程池示例

在分析线程池之前,先看一个简单的线程池示例。

 1 import java.util.concurrent.Executors;
 2 import java.util.concurrent.ExecutorService;
 3 
 4 public class ThreadPoolDemo1 {
 5 
 6     public static void main(String[] args) {
 7         // 创建一个可重用固定线程数的线程池
 8         ExecutorService pool = Executors.newFixedThreadPool(2);
 9         // 创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口
10         Thread ta = new MyThread();
11         Thread tb = new MyThread();
12         Thread tc = new MyThread();
13         Thread td = new MyThread();
14         Thread te = new MyThread();
15         // 将线程放入池中进行执行
16         pool.execute(ta);
17         pool.execute(tb);
18         pool.execute(tc);
19         pool.execute(td);
20         pool.execute(te);
21         // 关闭线程池
22         pool.shutdown();
23     }
24 }
25 
26 class MyThread extends Thread {
27 
28     @Override
29     public void run() {
30         System.out.println(Thread.currentThread().getName()+ " is running.");
31     }
32 }

运行结果

pool-1-thread-1 is running.
pool-1-thread-2 is running.
pool-1-thread-1 is running.
pool-1-thread-2 is running.
pool-1-thread-1 is running.

示例中,包括了线程池的创建,将任务添加到线程池中,关闭线程池这3个主要的步骤。稍后,我们会从这3个方面来分析ThreadPoolExecutor。

 

参考代码(基于JDK1.7.0_40)

Executors完整源码

  1 /*
  2  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  3  *
  4  *
  5  *
  6  *
  7  *
  8  *
  9  *
 10  *
 11  *
 12  *
 13  *
 14  *
 15  *
 16  *
 17  *
 18  *
 19  *
 20  *
 21  *
 22  *
 23  */
 24 
 25 /*
 26  *
 27  *
 28  *
 29  *
 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 
 36 package java.util.concurrent;
 37 import java.util.*;
 38 import java.util.concurrent.atomic.AtomicInteger;
 39 import java.security.AccessControlContext;
 40 import java.security.AccessController;
 41 import java.security.PrivilegedAction;
 42 import java.security.PrivilegedExceptionAction;
 43 import java.security.PrivilegedActionException;
 44 import java.security.AccessControlException;
 45 import sun.security.util.SecurityConstants;
 46 
 47 /**
 48  * Factory and utility methods for {@link Executor}, {@link
 49  * ExecutorService}, {@link ScheduledExecutorService}, {@link
 50  * ThreadFactory}, and {@link Callable} classes defined in this
 51  * package. This class supports the following kinds of methods:
 52  *
 53  * <ul>
 54  *   <li> Methods that create and return an {@link ExecutorService}
 55  *        set up with commonly useful configuration settings.
 56  *   <li> Methods that create and return a {@link ScheduledExecutorService}
 57  *        set up with commonly useful configuration settings.
 58  *   <li> Methods that create and return a "wrapped" ExecutorService, that
 59  *        disables reconfiguration by making implementation-specific methods
 60  *        inaccessible.
 61  *   <li> Methods that create and return a {@link ThreadFactory}
 62  *        that sets newly created threads to a known state.
 63  *   <li> Methods that create and return a {@link Callable}
 64  *        out of other closure-like forms, so they can be used
 65  *        in execution methods requiring <tt>Callable</tt>.
 66  * </ul>
 67  *
 68  * @since 1.5
 69  * @author Doug Lea
 70  */
 71 public class Executors {
 72 
 73     /**
 74      * Creates a thread pool that reuses a fixed number of threads
 75      * operating off a shared unbounded queue.  At any point, at most
 76      * <tt>nThreads</tt> threads will be active processing tasks.
 77      * If additional tasks are submitted when all threads are active,
 78      * they will wait in the queue until a thread is available.
 79      * If any thread terminates due to a failure during execution
 80      * prior to shutdown, a new one will take its place if needed to
 81      * execute subsequent tasks.  The threads in the pool will exist
 82      * until it is explicitly {@link ExecutorService#shutdown shutdown}.
 83      *
 84      * @param nThreads the number of threads in the pool
 85      * @return the newly created thread pool
 86      * @throws IllegalArgumentException if {@code nThreads <= 0}
 87      */
 88     public static ExecutorService newFixedThreadPool(int nThreads) {
 89         return new ThreadPoolExecutor(nThreads, nThreads,
 90                                       0L, TimeUnit.MILLISECONDS,
 91                                       new LinkedBlockingQueue<Runnable>());
 92     }
 93 
 94     /**
 95      * Creates a thread pool that reuses a fixed number of threads
 96      * operating off a shared unbounded queue, using the provided
 97      * ThreadFactory to create new threads when needed.  At any point,
 98      * at most <tt>nThreads</tt> threads will be active processing
 99      * tasks.  If additional tasks are submitted when all threads are
100      * active, they will wait in the queue until a thread is
101      * available.  If any thread terminates due to a failure during
102      * execution prior to shutdown, a new one will take its place if
103      * needed to execute subsequent tasks.  The threads in the pool will
104      * exist until it is explicitly {@link ExecutorService#shutdown
105      * shutdown}.
106      *
107      * @param nThreads the number of threads in the pool
108      * @param threadFactory the factory to use when creating new threads
109      * @return the newly created thread pool
110      * @throws NullPointerException if threadFactory is null
111      * @throws IllegalArgumentException if {@code nThreads <= 0}
112      */
113     public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
114         return new ThreadPoolExecutor(nThreads, nThreads,
115                                       0L, TimeUnit.MILLISECONDS,
116                                       new LinkedBlockingQueue<Runnable>(),
117                                       threadFactory);
118     }
119 
120     /**
121      * Creates an Executor that uses a single worker thread operating
122      * off an unbounded queue. (Note however that if this single
123      * thread terminates due to a failure during execution prior to
124      * shutdown, a new one will take its place if needed to execute
125      * subsequent tasks.)  Tasks are guaranteed to execute
126      * sequentially, and no more than one task will be active at any
127      * given time. Unlike the otherwise equivalent
128      * <tt>newFixedThreadPool(1)</tt> the returned executor is
129      * guaranteed not to be reconfigurable to use additional threads.
130      *
131      * @return the newly created single-threaded Executor
132      */
133     public static ExecutorService newSingleThreadExecutor() {
134         return new FinalizableDelegatedExecutorService
135             (new ThreadPoolExecutor(1, 1,
136                                     0L, TimeUnit.MILLISECONDS,
137                                     new LinkedBlockingQueue<Runnable>()));
138     }
139 
140     /**
141      * Creates an Executor that uses a single worker thread operating
142      * off an unbounded queue, and uses the provided ThreadFactory to
143      * create a new thread when needed. Unlike the otherwise
144      * equivalent <tt>newFixedThreadPool(1, threadFactory)</tt> the
145      * returned executor is guaranteed not to be reconfigurable to use
146      * additional threads.
147      *
148      * @param threadFactory the factory to use when creating new
149      * threads
150      *
151      * @return the newly created single-threaded Executor
152      * @throws NullPointerException if threadFactory is null
153      */
154     public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
155         return new FinalizableDelegatedExecutorService
156             (new ThreadPoolExecutor(1, 1,
157                                     0L, TimeUnit.MILLISECONDS,
158                                     new LinkedBlockingQueue<Runnable>(),
159                                     threadFactory));
160     }
161 
162     /**
163      * Creates a thread pool that creates new threads as needed, but
164      * will reuse previously constructed threads when they are
165      * available.  These pools will typically improve the performance
166      * of programs that execute many short-lived asynchronous tasks.
167      * Calls to <tt>execute</tt> will reuse previously constructed
168      * threads if available. If no existing thread is available, a new
169      * thread will be created and added to the pool. Threads that have
170      * not been used for sixty seconds are terminated and removed from
171      * the cache. Thus, a pool that remains idle for long enough will
172      * not consume any resources. Note that pools with similar
173      * properties but different details (for example, timeout parameters)
174      * may be created using {@link ThreadPoolExecutor} constructors.
175      *
176      * @return the newly created thread pool
177      */
178     public static ExecutorService newCachedThreadPool() {
179         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
180                                       60L, TimeUnit.SECONDS,
181                                       new SynchronousQueue<Runnable>());
182     }
183 
184     /**
185      * Creates a thread pool that creates new threads as needed, but
186      * will reuse previously constructed threads when they are
187      * available, and uses the provided
188      * ThreadFactory to create new threads when needed.
189      * @param threadFactory the factory to use when creating new threads
190      * @return the newly created thread pool
191      * @throws NullPointerException if threadFactory is null
192      */
193     public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
194         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
195                                       60L, TimeUnit.SECONDS,
196                                       new SynchronousQueue<Runnable>(),
197                                       threadFactory);
198     }
199 
200     /**
201      * Creates a single-threaded executor that can schedule commands
202      * to run after a given delay, or to execute periodically.
203      * (Note however that if this single
204      * thread terminates due to a failure during execution prior to
205      * shutdown, a new one will take its place if needed to execute
206      * subsequent tasks.)  Tasks are guaranteed to execute
207      * sequentially, and no more than one task will be active at any
208      * given time. Unlike the otherwise equivalent
209      * <tt>newScheduledThreadPool(1)</tt> the returned executor is
210      * guaranteed not to be reconfigurable to use additional threads.
211      * @return the newly created scheduled executor
212      */
213     public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
214         return new DelegatedScheduledExecutorService
215             (new ScheduledThreadPoolExecutor(1));
216     }
217 
218     /**
219      * Creates a single-threaded executor that can schedule commands
220      * to run after a given delay, or to execute periodically.  (Note
221      * however that if this single thread terminates due to a failure
222      * during execution prior to shutdown, a new one will take its
223      * place if needed to execute subsequent tasks.)  Tasks are
224      * guaranteed to execute sequentially, and no more than one task
225      * will be active at any given time. Unlike the otherwise
226      * equivalent <tt>newScheduledThreadPool(1, threadFactory)</tt>
227      * the returned executor is guaranteed not to be reconfigurable to
228      * use additional threads.
229      * @param threadFactory the factory to use when creating new
230      * threads
231      * @return a newly created scheduled executor
232      * @throws NullPointerException if threadFactory is null
233      */
234     public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
235         return new DelegatedScheduledExecutorService
236             (new ScheduledThreadPoolExecutor(1, threadFactory));
237     }
238 
239     /**
240      * Creates a thread pool that can schedule commands to run after a
241      * given delay, or to execute periodically.
242      * @param corePoolSize the number of threads to keep in the pool,
243      * even if they are idle.
244      * @return a newly created scheduled thread pool
245      * @throws IllegalArgumentException if {@code corePoolSize < 0}
246      */
247     public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
248         return new ScheduledThreadPoolExecutor(corePoolSize);
249     }
250 
251     /**
252      * Creates a thread pool that can schedule commands to run after a
253      * given delay, or to execute periodically.
254      * @param corePoolSize the number of threads to keep in the pool,
255      * even if they are idle.
256      * @param threadFactory the factory to use when the executor
257      * creates a new thread.
258      * @return a newly created scheduled thread pool
259      * @throws IllegalArgumentException if {@code corePoolSize < 0}
260      * @throws NullPointerException if threadFactory is null
261      */
262     public static ScheduledExecutorService newScheduledThreadPool(
263             int corePoolSize, ThreadFactory threadFactory) {
264         return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
265     }
266 
267 
268     /**
269      * Returns an object that delegates all defined {@link
270      * ExecutorService} methods to the given executor, but not any
271      * other methods that might otherwise be accessible using
272      * casts. This provides a way to safely "freeze" configuration and
273      * disallow tuning of a given concrete implementation.
274      * @param executor the underlying implementation
275      * @return an <tt>ExecutorService</tt> instance
276      * @throws NullPointerException if executor null
277      */
278     public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
279         if (executor == null)
280             throw new NullPointerException();
281         return new DelegatedExecutorService(executor);
282     }
283 
284     /**
285      * Returns an object that delegates all defined {@link
286      * ScheduledExecutorService} methods to the given executor, but
287      * not any other methods that might otherwise be accessible using
288      * casts. This provides a way to safely "freeze" configuration and
289      * disallow tuning of a given concrete implementation.
290      * @param executor the underlying implementation
291      * @return a <tt>ScheduledExecutorService</tt> instance
292      * @throws NullPointerException if executor null
293      */
294     public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor) {
295         if (executor == null)
296             throw new NullPointerException();
297         return new DelegatedScheduledExecutorService(executor);
298     }
299 
300     /**
301      * Returns a default thread factory used to create new threads.
302      * This factory creates all new threads used by an Executor in the
303      * same {@link ThreadGroup}. If there is a {@link
304      * java.lang.SecurityManager}, it uses the group of {@link
305      * System#getSecurityManager}, else the group of the thread
306      * invoking this <tt>defaultThreadFactory</tt> method. Each new
307      * thread is created as a non-daemon thread with priority set to
308      * the smaller of <tt>Thread.NORM_PRIORITY</tt> and the maximum
309      * priority permitted in the thread group.  New threads have names
310      * accessible via {@link Thread#getName} of
311      * <em>pool-N-thread-M</em>, where <em>N</em> is the sequence
312      * number of this factory, and <em>M</em> is the sequence number
313      * of the thread created by this factory.
314      * @return a thread factory
315      */
316     public static ThreadFactory defaultThreadFactory() {
317         return new DefaultThreadFactory();
318     }
319 
320     /**
321      * Returns a thread factory used to create new threads that
322      * have the same permissions as the current thread.
323      * This factory creates threads with the same settings as {@link
324      * Executors#defaultThreadFactory}, additionally setting the
325      * AccessControlContext and contextClassLoader of new threads to
326      * be the same as the thread invoking this
327      * <tt>privilegedThreadFactory</tt> method.  A new
328      * <tt>privilegedThreadFactory</tt> can be created within an
329      * {@link AccessController#doPrivileged} action setting the
330      * current thread's access control context to create threads with
331      * the selected permission settings holding within that action.
332      *
333      * <p> Note that while tasks running within such threads will have
334      * the same access control and class loader settings as the
335      * current thread, they need not have the same {@link
336      * java.lang.ThreadLocal} or {@link
337      * java.lang.InheritableThreadLocal} values. If necessary,
338      * particular values of thread locals can be set or reset before
339      * any task runs in {@link ThreadPoolExecutor} subclasses using
340      * {@link ThreadPoolExecutor#beforeExecute}. Also, if it is
341      * necessary to initialize worker threads to have the same
342      * InheritableThreadLocal settings as some other designated
343      * thread, you can create a custom ThreadFactory in which that
344      * thread waits for and services requests to create others that
345      * will inherit its values.
346      *
347      * @return a thread factory
348      * @throws AccessControlException if the current access control
349      * context does not have permission to both get and set context
350      * class loader.
351      */
352     public static ThreadFactory privilegedThreadFactory() {
353         return new PrivilegedThreadFactory();
354     }
355 
356     /**
357      * Returns a {@link Callable} object that, when
358      * called, runs the given task and returns the given result.  This
359      * can be useful when applying methods requiring a
360      * <tt>Callable</tt> to an otherwise resultless action.
361      * @param task the task to run
362      * @param result the result to return
363      * @return a callable object
364      * @throws NullPointerException if task null
365      */
366     public static <T> Callable<T> callable(Runnable task, T result) {
367         if (task == null)
368             throw new NullPointerException();
369         return new RunnableAdapter<T>(task, result);
370     }
371 
372     /**
373      * Returns a {@link Callable} object that, when
374      * called, runs the given task and returns <tt>null</tt>.
375      * @param task the task to run
376      * @return a callable object
377      * @throws NullPointerException if task null
378      */
379     public static Callable<Object> callable(Runnable task) {
380         if (task == null)
381             throw new NullPointerException();
382         return new RunnableAdapter<Object>(task, null);
383     }
384 
385     /**
386      * Returns a {@link Callable} object that, when
387      * called, runs the given privileged action and returns its result.
388      * @param action the privileged action to run
389      * @return a callable object
390      * @throws NullPointerException if action null
391      */
392     public static Callable<Object> callable(final PrivilegedAction<?> action) {
393         if (action == null)
394             throw new NullPointerException();
395         return new Callable<Object>() {
396             public Object call() { return action.run(); }};
397     }
398 
399     /**
400      * Returns a {@link Callable} object that, when
401      * called, runs the given privileged exception action and returns
402      * its result.
403      * @param action the privileged exception action to run
404      * @return a callable object
405      * @throws NullPointerException if action null
406      */
407     public static Callable<Object> callable(final PrivilegedExceptionAction<?> action) {
408         if (action == null)
409             throw new NullPointerException();
410         return new Callable<Object>() {
411             public Object call() throws Exception { return action.run(); }};
412     }
413 
414     /**
415      * Returns a {@link Callable} object that will, when
416      * called, execute the given <tt>callable</tt> under the current
417      * access control context. This method should normally be
418      * invoked within an {@link AccessController#doPrivileged} action
419      * to create callables that will, if possible, execute under the
420      * selected permission settings holding within that action; or if
421      * not possible, throw an associated {@link
422      * AccessControlException}.
423      * @param callable the underlying task
424      * @return a callable object
425      * @throws NullPointerException if callable null
426      *
427      */
428     public static <T> Callable<T> privilegedCallable(Callable<T> callable) {
429         if (callable == null)
430             throw new NullPointerException();
431         return new PrivilegedCallable<T>(callable);
432     }
433 
434     /**
435      * Returns a {@link Callable} object that will, when
436      * called, execute the given <tt>callable</tt> under the current
437      * access control context, with the current context class loader
438      * as the context class loader. This method should normally be
439      * invoked within an {@link AccessController#doPrivileged} action
440      * to create callables that will, if possible, execute under the
441      * selected permission settings holding within that action; or if
442      * not possible, throw an associated {@link
443      * AccessControlException}.
444      * @param callable the underlying task
445      *
446      * @return a callable object
447      * @throws NullPointerException if callable null
448      * @throws AccessControlException if the current access control
449      * context does not have permission to both set and get context
450      * class loader.
451      */
452     public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable) {
453         if (callable == null)
454             throw new NullPointerException();
455         return new PrivilegedCallableUsingCurrentClassLoader<T>(callable);
456     }
457 
458     // Non-public classes supporting the public methods
459 
460     /**
461      * A callable that runs given task and returns given result
462      */
463     static final class RunnableAdapter<T> implements Callable<T> {
464         final Runnable task;
465         final T result;
466         RunnableAdapter(Runnable task, T result) {
467             this.task = task;
468             this.result = result;
469         }
470         public T call() {
471             task.run();
472             return result;
473         }
474     }
475 
476     /**
477      * A callable that runs under established access control settings
478      */
479     static final class PrivilegedCallable<T> implements Callable<T> {
480         private final Callable<T> task;
481         private final AccessControlContext acc;
482 
483         PrivilegedCallable(Callable<T> task) {
484             this.task = task;
485             this.acc = AccessController.getContext();
486         }
487 
488         public T call() throws Exception {
489             try {
490                 return AccessController.doPrivileged(
491                     new PrivilegedExceptionAction<T>() {
492                         public T run() throws Exception {
493                             return task.call();
494                         }
495                     }, acc);
496             } catch (PrivilegedActionException e) {
497                 throw e.getException();
498             }
499         }
500     }
501 
502     /**
503      * A callable that runs under established access control settings and
504      * current ClassLoader
505      */
506     static final class PrivilegedCallableUsingCurrentClassLoader<T> implements Callable<T> {
507         private final Callable<T> task;
508         private final AccessControlContext acc;
509         private final ClassLoader ccl;
510 
511         PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
512             SecurityManager sm = System.getSecurityManager();
513             if (sm != null) {
514                 // Calls to getContextClassLoader from this class
515                 // never trigger a security check, but we check
516                 // whether our callers have this permission anyways.
517                 sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
518 
519                 // Whether setContextClassLoader turns out to be necessary
520                 // or not, we fail fast if permission is not available.
521                 sm.checkPermission(new RuntimePermission("setContextClassLoader"));
522             }
523             this.task = task;
524             this.acc = AccessController.getContext();
525             this.ccl = Thread.currentThread().getContextClassLoader();
526         }
527 
528         public T call() throws Exception {
529             try {
530                 return AccessController.doPrivileged(
531                     new PrivilegedExceptionAction<T>() {
532                         public T run() throws Exception {
533                             Thread t = Thread.currentThread();
534                             ClassLoader cl = t.getContextClassLoader();
535                             if (ccl == cl) {
536                                 return task.call();
537                             } else {
538                                 t.setContextClassLoader(ccl);
539                                 try {
540                                     return task.call();
541                                 } finally {
542                                     t.setContextClassLoader(cl);
543                                 }
544                             }
545                         }
546                     }, acc);
547             } catch (PrivilegedActionException e) {
548                 throw e.getException();
549             }
550         }
551     }
552 
553     /**
554      * The default thread factory
555      */
556     static class DefaultThreadFactory implements ThreadFactory {
557         private static final AtomicInteger poolNumber = new AtomicInteger(1);
558         private final ThreadGroup group;
559         private final AtomicInteger threadNumber = new AtomicInteger(1);
560         private final String namePrefix;
561 
562         DefaultThreadFactory() {
563             SecurityManager s = System.getSecurityManager();
564             group = (s != null) ? s.getThreadGroup() :
565                                   Thread.currentThread().getThreadGroup();
566             namePrefix = "pool-" +
567                           poolNumber.getAndIncrement() +
568                          "-thread-";
569         }
570 
571         public Thread newThread(Runnable r) {
572             Thread t = new Thread(group, r,
573                                   namePrefix + threadNumber.getAndIncrement(),
574                                   0);
575             if (t.isDaemon())
576                 t.setDaemon(false);
577             if (t.getPriority() != Thread.NORM_PRIORITY)
578                 t.setPriority(Thread.NORM_PRIORITY);
579             return t;
580         }
581     }
582 
583     /**
584      * Thread factory capturing access control context and class loader
585      */
586     static class PrivilegedThreadFactory extends DefaultThreadFactory {
587         private final AccessControlContext acc;
588         private final ClassLoader ccl;
589 
590         PrivilegedThreadFactory() {
591             super();
592             SecurityManager sm = System.getSecurityManager();
593             if (sm != null) {
594                 // Calls to getContextClassLoader from this class
595                 // never trigger a security check, but we check
596                 // whether our callers have this permission anyways.
597                 sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
598 
599                 // Fail fast
600                 sm.checkPermission(new RuntimePermission("setContextClassLoader"));
601             }
602             this.acc = AccessController.getContext();
603             this.ccl = Thread.currentThread().getContextClassLoader();
604         }
605 
606         public Thread newThread(final Runnable r) {
607             return super.newThread(new Runnable() {
608                 public void run() {
609                     AccessController.doPrivileged(new PrivilegedAction<Void>() {
610                         public Void run() {
611                             Thread.currentThread().setContextClassLoader(ccl);
612                             r.run();
613                             return null;
614                         }
615                     }, acc);
616                 }
617             });
618         }
619     }
620 
621     /**
622      * A wrapper class that exposes only the ExecutorService methods
623      * of an ExecutorService implementation.
624      */
625     static class DelegatedExecutorService extends AbstractExecutorService {
626         private final ExecutorService e;
627         DelegatedExecutorService(ExecutorService executor) { e = executor; }
628         public void execute(Runnable command) { e.execute(command); }
629         public void shutdown() { e.shutdown(); }
630         public List<Runnable> shutdownNow() { return e.shutdownNow(); }
631         public boolean isShutdown() { return e.isShutdown(); }
632         public boolean isTerminated() { return e.isTerminated(); }
633         public boolean awaitTermination(long timeout, TimeUnit unit)
634             throws InterruptedException {
635             return e.awaitTermination(timeout, unit);
636         }
637         public Future<?> submit(Runnable task) {
638             return e.submit(task);
639         }
640         public <T> Future<T> submit(Callable<T> task) {
641             return e.submit(task);
642         }
643         public <T> Future<T> submit(Runnable task, T result) {
644             return e.submit(task, result);
645         }
646         public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
647             throws InterruptedException {
648             return e.invokeAll(tasks);
649         }
650         public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
651                                              long timeout, TimeUnit unit)
652             throws InterruptedException {
653             return e.invokeAll(tasks, timeout, unit);
654         }
655         public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
656             throws InterruptedException, ExecutionException {
657             return e.invokeAny(tasks);
658         }
659         public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
660                                long timeout, TimeUnit unit)
661             throws InterruptedException, ExecutionException, TimeoutException {
662             return e.invokeAny(tasks, timeout, unit);
663         }
664     }
665 
666     static class FinalizableDelegatedExecutorService
667         extends DelegatedExecutorService {
668         FinalizableDelegatedExecutorService(ExecutorService executor) {
669             super(executor);
670         }
671         protected void finalize() {
672             super.shutdown();
673         }
674     }
675 
676     /**
677      * A wrapper class that exposes only the ScheduledExecutorService
678      * methods of a ScheduledExecutorService implementation.
679      */
680     static class DelegatedScheduledExecutorService
681             extends DelegatedExecutorService
682             implements ScheduledExecutorService {
683         private final ScheduledExecutorService e;
684         DelegatedScheduledExecutorService(ScheduledExecutorService executor) {
685             super(executor);
686             e = executor;
687         }
688         public ScheduledFuture<?> schedule(Runnable command, long delay,  TimeUnit unit) {
689             return e.schedule(command, delay, unit);
690         }
691         public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
692             return e.schedule(callable, delay, unit);
693         }
694         public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay,  long period, TimeUnit unit) {
695             return e.scheduleAtFixedRate(command, initialDelay, period, unit);
696         }
697         public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay,  long delay, TimeUnit unit) {
698             return e.scheduleWithFixedDelay(command, initialDelay, delay, unit);
699         }
700     }
701 
702 
703     /** Cannot instantiate. */
704     private Executors() {}
705 }
View Code

 

ThreadPoolExecutor完整源码

   1 /*
   2  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
   3  *
   4  *
   5  *
   6  *
   7  *
   8  *
   9  *
  10  *
  11  *
  12  *
  13  *
  14  *
  15  *
  16  *
  17  *
  18  *
  19  *
  20  *
  21  *
  22  *
  23  */
  24 
  25 /*
  26  *
  27  *
  28  *
  29  *
  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 
  36 package java.util.concurrent;
  37 import java.util.concurrent.locks.AbstractQueuedSynchronizer;
  38 import java.util.concurrent.locks.Condition;
  39 import java.util.concurrent.locks.ReentrantLock;
  40 import java.util.concurrent.atomic.AtomicInteger;
  41 import java.util.*;
  42 
  43 /**
  44  * An {@link ExecutorService} that executes each submitted task using
  45  * one of possibly several pooled threads, normally configured
  46  * using {@link Executors} factory methods.
  47  *
  48  * <p>Thread pools address two different problems: they usually
  49  * provide improved performance when executing large numbers of
  50  * asynchronous tasks, due to reduced per-task invocation overhead,
  51  * and they provide a means of bounding and managing the resources,
  52  * including threads, consumed when executing a collection of tasks.
  53  * Each {@code ThreadPoolExecutor} also maintains some basic
  54  * statistics, such as the number of completed tasks.
  55  *
  56  * <p>To be useful across a wide range of contexts, this class
  57  * provides many adjustable parameters and extensibility
  58  * hooks. However, programmers are urged to use the more convenient
  59  * {@link Executors} factory methods {@link
  60  * Executors#newCachedThreadPool} (unbounded thread pool, with
  61  * automatic thread reclamation), {@link Executors#newFixedThreadPool}
  62  * (fixed size thread pool) and {@link
  63  * Executors#newSingleThreadExecutor} (single background thread), that
  64  * preconfigure settings for the most common usage
  65  * scenarios. Otherwise, use the following guide when manually
  66  * configuring and tuning this class:
  67  *
  68  * <dl>
  69  *
  70  * <dt>Core and maximum pool sizes</dt>
  71  *
  72  * <dd>A {@code ThreadPoolExecutor} will automatically adjust the
  73  * pool size (see {@link #getPoolSize})
  74  * according to the bounds set by
  75  * corePoolSize (see {@link #getCorePoolSize}) and
  76  * maximumPoolSize (see {@link #getMaximumPoolSize}).
  77  *
  78  * When a new task is submitted in method {@link #execute}, and fewer
  79  * than corePoolSize threads are running, a new thread is created to
  80  * handle the request, even if other worker threads are idle.  If
  81  * there are more than corePoolSize but less than maximumPoolSize
  82  * threads running, a new thread will be created only if the queue is
  83  * full.  By setting corePoolSize and maximumPoolSize the same, you
  84  * create a fixed-size thread pool. By setting maximumPoolSize to an
  85  * essentially unbounded value such as {@code Integer.MAX_VALUE}, you
  86  * allow the pool to accommodate an arbitrary number of concurrent
  87  * tasks. Most typically, core and maximum pool sizes are set only
  88  * upon construction, but they may also be changed dynamically using
  89  * {@link #setCorePoolSize} and {@link #setMaximumPoolSize}. </dd>
  90  *
  91  * <dt>On-demand construction</dt>
  92  *
  93  * <dd> By default, even core threads are initially created and
  94  * started only when new tasks arrive, but this can be overridden
  95  * dynamically using method {@link #prestartCoreThread} or {@link
  96  * #prestartAllCoreThreads}.  You probably want to prestart threads if
  97  * you construct the pool with a non-empty queue. </dd>
  98  *
  99  * <dt>Creating new threads</dt>
 100  *
 101  * <dd>New threads are created using a {@link ThreadFactory}.  If not
 102  * otherwise specified, a {@link Executors#defaultThreadFactory} is
 103  * used, that creates threads to all be in the same {@link
 104  * ThreadGroup} and with the same {@code NORM_PRIORITY} priority and
 105  * non-daemon status. By supplying a different ThreadFactory, you can
 106  * alter the thread's name, thread group, priority, daemon status,
 107  * etc. If a {@code ThreadFactory} fails to create a thread when asked
 108  * by returning null from {@code newThread}, the executor will
 109  * continue, but might not be able to execute any tasks. Threads
 110  * should possess the "modifyThread" {@code RuntimePermission}. If
 111  * worker threads or other threads using the pool do not possess this
 112  * permission, service may be degraded: configuration changes may not
 113  * take effect in a timely manner, and a shutdown pool may remain in a
 114  * state in which termination is possible but not completed.</dd>
 115  *
 116  * <dt>Keep-alive times</dt>
 117  *
 118  * <dd>If the pool currently has more than corePoolSize threads,
 119  * excess threads will be terminated if they have been idle for more
 120  * than the keepAliveTime (see {@link #getKeepAliveTime}). This
 121  * provides a means of reducing resource consumption when the pool is
 122  * not being actively used. If the pool becomes more active later, new
 123  * threads will be constructed. This parameter can also be changed
 124  * dynamically using method {@link #setKeepAliveTime}. Using a value
 125  * of {@code Long.MAX_VALUE} {@link TimeUnit#NANOSECONDS} effectively
 126  * disables idle threads from ever terminating prior to shut down. By
 127  * default, the keep-alive policy applies only when there are more
 128  * than corePoolSizeThreads. But method {@link
 129  * #allowCoreThreadTimeOut(boolean)} can be used to apply this
 130  * time-out policy to core threads as well, so long as the
 131  * keepAliveTime value is non-zero. </dd>
 132  *
 133  * <dt>Queuing</dt>
 134  *
 135  * <dd>Any {@link BlockingQueue} may be used to transfer and hold
 136  * submitted tasks.  The use of this queue interacts with pool sizing:
 137  *
 138  * <ul>
 139  *
 140  * <li> If fewer than corePoolSize threads are running, the Executor
 141  * always prefers adding a new thread
 142  * rather than queuing.</li>
 143  *
 144  * <li> If corePoolSize or more threads are running, the Executor
 145  * always prefers queuing a request rather than adding a new
 146  * thread.</li>
 147  *
 148  * <li> If a request cannot be queued, a new thread is created unless
 149  * this would exceed maximumPoolSize, in which case, the task will be
 150  * rejected.</li>
 151  *
 152  * </ul>
 153  *
 154  * There are three general strategies for queuing:
 155  * <ol>
 156  *
 157  * <li> <em> Direct handoffs.</em> A good default choice for a work
 158  * queue is a {@link SynchronousQueue} that hands off tasks to threads
 159  * without otherwise holding them. Here, an attempt to queue a task
 160  * will fail if no threads are immediately available to run it, so a
 161  * new thread will be constructed. This policy avoids lockups when
 162  * handling sets of requests that might have internal dependencies.
 163  * Direct handoffs generally require unbounded maximumPoolSizes to
 164  * avoid rejection of new submitted tasks. This in turn admits the
 165  * possibility of unbounded thread growth when commands continue to
 166  * arrive on average faster than they can be processed.  </li>
 167  *
 168  * <li><em> Unbounded queues.</em> Using an unbounded queue (for
 169  * example a {@link LinkedBlockingQueue} without a predefined
 170  * capacity) will cause new tasks to wait in the queue when all
 171  * corePoolSize threads are busy. Thus, no more than corePoolSize
 172  * threads will ever be created. (And the value of the maximumPoolSize
 173  * therefore doesn't have any effect.)  This may be appropriate when
 174  * each task is completely independent of others, so tasks cannot
 175  * affect each others execution; for example, in a web page server.
 176  * While this style of queuing can be useful in smoothing out
 177  * transient bursts of requests, it admits the possibility of
 178  * unbounded work queue growth when commands continue to arrive on
 179  * average faster than they can be processed.  </li>
 180  *
 181  * <li><em>Bounded queues.</em> A bounded queue (for example, an
 182  * {@link ArrayBlockingQueue}) helps prevent resource exhaustion when
 183  * used with finite maximumPoolSizes, but can be more difficult to
 184  * tune and control.  Queue sizes and maximum pool sizes may be traded
 185  * off for each other: Using large queues and small pools minimizes
 186  * CPU usage, OS resources, and context-switching overhead, but can
 187  * lead to artificially low throughput.  If tasks frequently block (for
 188  * example if they are I/O bound), a system may be able to schedule
 189  * time for more threads than you otherwise allow. Use of small queues
 190  * generally requires larger pool sizes, which keeps CPUs busier but
 191  * may encounter unacceptable scheduling overhead, which also
 192  * decreases throughput.  </li>
 193  *
 194  * </ol>
 195  *
 196  * </dd>
 197  *
 198  * <dt>Rejected tasks</dt>
 199  *
 200  * <dd> New tasks submitted in method {@link #execute} will be
 201  * <em>rejected</em> when the Executor has been shut down, and also
 202  * when the Executor uses finite bounds for both maximum threads and
 203  * work queue capacity, and is saturated.  In either case, the {@code
 204  * execute} method invokes the {@link
 205  * RejectedExecutionHandler#rejectedExecution} method of its {@link
 206  * RejectedExecutionHandler}.  Four predefined handler policies are
 207  * provided:
 208  *
 209  * <ol>
 210  *
 211  * <li> In the default {@link ThreadPoolExecutor.AbortPolicy}, the
 212  * handler throws a runtime {@link RejectedExecutionException} upon
 213  * rejection. </li>
 214  *
 215  * <li> In {@link ThreadPoolExecutor.CallerRunsPolicy}, the thread
 216  * that invokes {@code execute} itself runs the task. This provides a
 217  * simple feedback control mechanism that will slow down the rate that
 218  * new tasks are submitted. </li>
 219  *
 220  * <li> In {@link ThreadPoolExecutor.DiscardPolicy}, a task that
 221  * cannot be executed is simply dropped.  </li>
 222  *
 223  * <li>In {@link ThreadPoolExecutor.DiscardOldestPolicy}, if the
 224  * executor is not shut down, the task at the head of the work queue
 225  * is dropped, and then execution is retried (which can fail again,
 226  * causing this to be repeated.) </li>
 227  *
 228  * </ol>
 229  *
 230  * It is possible to define and use other kinds of {@link
 231  * RejectedExecutionHandler} classes. Doing so requires some care
 232  * especially when policies are designed to work only under particular
 233  * capacity or queuing policies. </dd>
 234  *
 235  * <dt>Hook methods</dt>
 236  *
 237  * <dd>This class provides {@code protected} overridable {@link
 238  * #beforeExecute} and {@link #afterExecute} methods that are called
 239  * before and after execution of each task.  These can be used to
 240  * manipulate the execution environment; for example, reinitializing
 241  * ThreadLocals, gathering statistics, or adding log
 242  * entries. Additionally, method {@link #terminated} can be overridden
 243  * to perform any special processing that needs to be done once the
 244  * Executor has fully terminated.
 245  *
 246  * <p>If hook or callback methods throw exceptions, internal worker
 247  * threads may in turn fail and abruptly terminate.</dd>
 248  *
 249  * <dt>Queue maintenance</dt>
 250  *
 251  * <dd> Method {@link #getQueue} allows access to the work queue for
 252  * purposes of monitoring and debugging.  Use of this method for any
 253  * other purpose is strongly discouraged.  Two supplied methods,
 254  * {@link #remove} and {@link #purge} are available to assist in
 255  * storage reclamation when large numbers of queued tasks become
 256  * cancelled.</dd>
 257  *
 258  * <dt>Finalization</dt>
 259  *
 260  * <dd> A pool that is no longer referenced in a program <em>AND</em>
 261  * has no remaining threads will be {@code shutdown} automatically. If
 262  * you would like to ensure that unreferenced pools are reclaimed even
 263  * if users forget to call {@link #shutdown}, then you must arrange
 264  * that unused threads eventually die, by setting appropriate
 265  * keep-alive times, using a lower bound of zero core threads and/or
 266  * setting {@link #allowCoreThreadTimeOut(boolean)}.  </dd>
 267  *
 268  * </dl>
 269  *
 270  * <p> <b>Extension example</b>. Most extensions of this class
 271  * override one or more of the protected hook methods. For example,
 272  * here is a subclass that adds a simple pause/resume feature:
 273  *
 274  *  <pre> {@code
 275  * class PausableThreadPoolExecutor extends ThreadPoolExecutor {
 276  *   private boolean isPaused;
 277  *   private ReentrantLock pauseLock = new ReentrantLock();
 278  *   private Condition unpaused = pauseLock.newCondition();
 279  *
 280  *   public PausableThreadPoolExecutor(...) { super(...); }
 281  *
 282  *   protected void beforeExecute(Thread t, Runnable r) {
 283  *     super.beforeExecute(t, r);
 284  *     pauseLock.lock();
 285  *     try {
 286  *       while (isPaused) unpaused.await();
 287  *     } catch (InterruptedException ie) {
 288  *       t.interrupt();
 289  *     } finally {
 290  *       pauseLock.unlock();
 291  *     }
 292  *   }
 293  *
 294  *   public void pause() {
 295  *     pauseLock.lock();
 296  *     try {
 297  *       isPaused = true;
 298  *     } finally {
 299  *       pauseLock.unlock();
 300  *     }
 301  *   }
 302  *
 303  *   public void resume() {
 304  *     pauseLock.lock();
 305  *     try {
 306  *       isPaused = false;
 307  *       unpaused.signalAll();
 308  *     } finally {
 309  *       pauseLock.unlock();
 310  *     }
 311  *   }
 312  * }}</pre>
 313  *
 314  * @since 1.5
 315  * @author Doug Lea
 316  */
 317 public class ThreadPoolExecutor extends AbstractExecutorService {
 318     /**
 319      * The main pool control state, ctl, is an atomic integer packing
 320      * two conceptual fields
 321      *   workerCount, indicating the effective number of threads
 322      *   runState,    indicating whether running, shutting down etc
 323      *
 324      * In order to pack them into one int, we limit workerCount to
 325      * (2^29)-1 (about 500 million) threads rather than (2^31)-1 (2
 326      * billion) otherwise representable. If this is ever an issue in
 327      * the future, the variable can be changed to be an AtomicLong,
 328      * and the shift/mask constants below adjusted. But until the need
 329      * arises, this code is a bit faster and simpler using an int.
 330      *
 331      * The workerCount is the number of workers that have been
 332      * permitted to start and not permitted to stop.  The value may be
 333      * transiently different from the actual number of live threads,
 334      * for example when a ThreadFactory fails to create a thread when
 335      * asked, and when exiting threads are still performing
 336      * bookkeeping before terminating. The user-visible pool size is
 337      * reported as the current size of the workers set.
 338      *
 339      * The runState provides the main lifecyle control, taking on values:
 340      *
 341      *   RUNNING:  Accept new tasks and process queued tasks
 342      *   SHUTDOWN: Don't accept new tasks, but process queued tasks
 343      *   STOP:     Don't accept new tasks, don't process queued tasks,
 344      *             and interrupt in-progress tasks
 345      *   TIDYING:  All tasks have terminated, workerCount is zero,
 346      *             the thread transitioning to state TIDYING
 347      *             will run the terminated() hook method
 348      *   TERMINATED: terminated() has completed
 349      *
 350      * The numerical order among these values matters, to allow
 351      * ordered comparisons. The runState monotonically increases over
 352      * time, but need not hit each state. The transitions are:
 353      *
 354      * RUNNING -> SHUTDOWN
 355      *    On invocation of shutdown(), perhaps implicitly in finalize()
 356      * (RUNNING or SHUTDOWN) -> STOP
 357      *    On invocation of shutdownNow()
 358      * SHUTDOWN -> TIDYING
 359      *    When both queue and pool are empty
 360      * STOP -> TIDYING
 361      *    When pool is empty
 362      * TIDYING -> TERMINATED
 363      *    When the terminated() hook method has completed
 364      *
 365      * Threads waiting in awaitTermination() will return when the
 366      * state reaches TERMINATED.
 367      *
 368      * Detecting the transition from SHUTDOWN to TIDYING is less
 369      * straightforward than you'd like because the queue may become
 370      * empty after non-empty and vice versa during SHUTDOWN state, but
 371      * we can only terminate if, after seeing that it is empty, we see
 372      * that workerCount is 0 (which sometimes entails a recheck -- see
 373      * below).
 374      */
 375     private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
 376     private static final int COUNT_BITS = Integer.SIZE - 3;
 377     private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
 378 
 379     // runState is stored in the high-order bits
 380     private static final int RUNNING    = -1 << COUNT_BITS;
 381     private static final int SHUTDOWN   =  0 << COUNT_BITS;
 382     private static final int STOP       =  1 << COUNT_BITS;
 383     private static final int TIDYING    =  2 << COUNT_BITS;
 384     private static final int TERMINATED =  3 << COUNT_BITS;
 385 
 386     // Packing and unpacking ctl
 387     private static int runStateOf(int c)     { return c & ~CAPACITY; }
 388     private static int workerCountOf(int c)  { return c & CAPACITY; }
 389     private static int ctlOf(int rs, int wc) { return rs | wc; }
 390 
 391     /*
 392      * Bit field accessors that don't require unpacking ctl.
 393      * These depend on the bit layout and on workerCount being never negative.
 394      */
 395 
 396     private static boolean runStateLessThan(int c, int s) {
 397         return c < s;
 398     }
 399 
 400     private static boolean runStateAtLeast(int c, int s) {
 401         return c >= s;
 402     }
 403 
 404     private static boolean isRunning(int c) {
 405         return c < SHUTDOWN;
 406     }
 407 
 408     /**
 409      * Attempt to CAS-increment the workerCount field of ctl.
 410      */
 411     private boolean compareAndIncrementWorkerCount(int expect) {
 412         return ctl.compareAndSet(expect, expect + 1);
 413     }
 414 
 415     /**
 416      * Attempt to CAS-decrement the workerCount field of ctl.
 417      */
 418     private boolean compareAndDecrementWorkerCount(int expect) {
 419         return ctl.compareAndSet(expect, expect - 1);
 420     }
 421 
 422     /**
 423      * Decrements the workerCount field of ctl. This is called only on
 424      * abrupt termination of a thread (see processWorkerExit). Other
 425      * decrements are performed within getTask.
 426      */
 427     private void decrementWorkerCount() {
 428         do {} while (! compareAndDecrementWorkerCount(ctl.get()));
 429     }
 430 
 431     /**
 432      * The queue used for holding tasks and handing off to worker
 433      * threads.  We do not require that workQueue.poll() returning
 434      * null necessarily means that workQueue.isEmpty(), so rely
 435      * solely on isEmpty to see if the queue is empty (which we must
 436      * do for example when deciding whether to transition from
 437      * SHUTDOWN to TIDYING).  This accommodates special-purpose
 438      * queues such as DelayQueues for which poll() is allowed to
 439      * return null even if it may later return non-null when delays
 440      * expire.
 441      */
 442     private final BlockingQueue<Runnable> workQueue;
 443 
 444     /**
 445      * Lock held on access to workers set and related bookkeeping.
 446      * While we could use a concurrent set of some sort, it turns out
 447      * to be generally preferable to use a lock. Among the reasons is
 448      * that this serializes interruptIdleWorkers, which avoids
 449      * unnecessary interrupt storms, especially during shutdown.
 450      * Otherwise exiting threads would concurrently interrupt those
 451      * that have not yet interrupted. It also simplifies some of the
 452      * associated statistics bookkeeping of largestPoolSize etc. We
 453      * also hold mainLock on shutdown and shutdownNow, for the sake of
 454      * ensuring workers set is stable while separately checking
 455      * permission to interrupt and actually interrupting.
 456      */
 457     private final ReentrantLock mainLock = new ReentrantLock();
 458 
 459     /**
 460      * Set containing all worker threads in pool. Accessed only when
 461      * holding mainLock.
 462      */
 463     private final HashSet<Worker> workers = new HashSet<Worker>();
 464 
 465     /**
 466      * Wait condition to support awaitTermination
 467      */
 468     private final Condition termination = mainLock.newCondition();
 469 
 470     /**
 471      * Tracks largest attained pool size. Accessed only under
 472      * mainLock.
 473      */
 474     private int largestPoolSize;
 475 
 476     /**
 477      * Counter for completed tasks. Updated only on termination of
 478      * worker threads. Accessed only under mainLock.
 479      */
 480     private long completedTaskCount;
 481 
 482     /*
 483      * All user control parameters are declared as volatiles so that
 484      * ongoing actions are based on freshest values, but without need
 485      * for locking, since no internal invariants depend on them
 486      * changing synchronously with respect to other actions.
 487      */
 488 
 489     /**
 490      * Factory for new threads. All threads are created using this
 491      * factory (via method addWorker).  All callers must be prepared
 492      * for addWorker to fail, which may reflect a system or user's
 493      * policy limiting the number of threads.  Even though it is not
 494      * treated as an error, failure to create threads may result in
 495      * new tasks being rejected or existing ones remaining stuck in
 496      * the queue.
 497      *
 498      * We go further and preserve pool invariants even in the face of
 499      * errors such as OutOfMemoryError, that might be thrown while
 500      * trying to create threads.  Such errors are rather common due to
 501      * the need to allocate a native stack in Thread#start, and users
 502      * will want to perform clean pool shutdown to clean up.  There
 503      * will likely be enough memory available for the cleanup code to
 504      * complete without encountering yet another OutOfMemoryError.
 505      */
 506     private volatile ThreadFactory threadFactory;
 507 
 508     /**
 509      * Handler called when saturated or shutdown in execute.
 510      */
 511     private volatile RejectedExecutionHandler handler;
 512 
 513     /**
 514      * Timeout in nanoseconds for idle threads waiting for work.
 515      * Threads use this timeout when there are more than corePoolSize
 516      * present or if allowCoreThreadTimeOut. Otherwise they wait
 517      * forever for new work.
 518      */
 519     private volatile long keepAliveTime;
 520 
 521     /**
 522      * If false (default), core threads stay alive even when idle.
 523      * If true, core threads use keepAliveTime to time out waiting
 524      * for work.
 525      */
 526     private volatile boolean allowCoreThreadTimeOut;
 527 
 528     /**
 529      * Core pool size is the minimum number of workers to keep alive
 530      * (and not allow to time out etc) unless allowCoreThreadTimeOut
 531      * is set, in which case the minimum is zero.
 532      */
 533     private volatile int corePoolSize;
 534 
 535     /**
 536      * Maximum pool size. Note that the actual maximum is internally
 537      * bounded by CAPACITY.
 538      */
 539     private volatile int maximumPoolSize;
 540 
 541     /**
 542      * The default rejected execution handler
 543      */
 544     private static final RejectedExecutionHandler defaultHandler =
 545         new AbortPolicy();
 546 
 547     /**
 548      * Permission required for callers of shutdown and shutdownNow.
 549      * We additionally require (see checkShutdownAccess) that callers
 550      * have permission to actually interrupt threads in the worker set
 551      * (as governed by Thread.interrupt, which relies on
 552      * ThreadGroup.checkAccess, which in turn relies on
 553      * SecurityManager.checkAccess). Shutdowns are attempted only if
 554      * these checks pass.
 555      *
 556      * All actual invocations of Thread.interrupt (see
 557      * interruptIdleWorkers and interruptWorkers) ignore
 558      * SecurityExceptions, meaning that the attempted interrupts
 559      * silently fail. In the case of shutdown, they should not fail
 560      * unless the SecurityManager has inconsistent policies, sometimes
 561      * allowing access to a thread and sometimes not. In such cases,
 562      * failure to actually interrupt threads may disable or delay full
 563      * termination. Other uses of interruptIdleWorkers are advisory,
 564      * and failure to actually interrupt will merely delay response to
 565      * configuration changes so is not handled exceptionally.
 566      */
 567     private static final RuntimePermission shutdownPerm =
 568         new RuntimePermission("modifyThread");
 569 
 570     /**
 571      * Class Worker mainly maintains interrupt control state for
 572      * threads running tasks, along with other minor bookkeeping.
 573      * This class opportunistically extends AbstractQueuedSynchronizer
 574      * to simplify acquiring and releasing a lock surrounding each
 575      * task execution.  This protects against interrupts that are
 576      * intended to wake up a worker thread waiting for a task from
 577      * instead interrupting a task being run.  We implement a simple
 578      * non-reentrant mutual exclusion lock rather than use
 579      * ReentrantLock because we do not want worker tasks to be able to
 580      * reacquire the lock when they invoke pool control methods like
 581      * setCorePoolSize.  Additionally, to suppress interrupts until
 582      * the thread actually starts running tasks, we initialize lock
 583      * state to a negative value, and clear it upon start (in
 584      * runWorker).
 585      */
 586     private final class Worker
 587         extends AbstractQueuedSynchronizer
 588         implements Runnable
 589     {
 590         /**
 591          * This class will never be serialized, but we provide a
 592          * serialVersionUID to suppress a javac warning.
 593          */
 594         private static final long serialVersionUID = 6138294804551838833L;
 595 
 596         /** Thread this worker is running in.  Null if factory fails. */
 597         final Thread thread;
 598         /** Initial task to run.  Possibly null. */
 599         Runnable firstTask;
 600         /** Per-thread task counter */
 601         volatile long completedTasks;
 602 
 603         /**
 604          * Creates with given first task and thread from ThreadFactory.
 605          * @param firstTask the first task (null if none)
 606          */
 607         Worker(Runnable firstTask) {
 608             setState(-1); // inhibit interrupts until runWorker
 609             this.firstTask = firstTask;
 610             this.thread = getThreadFactory().newThread(this);
 611         }
 612 
 613         /** Delegates main run loop to outer runWorker  */
 614         public void run() {
 615             runWorker(this);
 616         }
 617 
 618         // Lock methods
 619         //
 620         // The value 0 represents the unlocked state.
 621         // The value 1 represents the locked state.
 622 
 623         protected boolean isHeldExclusively() {
 624             return getState() != 0;
 625         }
 626 
 627         protected boolean tryAcquire(int unused) {
 628             if (compareAndSetState(0, 1)) {
 629                 setExclusiveOwnerThread(Thread.currentThread());
 630                 return true;
 631             }
 632             return false;
 633         }
 634 
 635         protected boolean tryRelease(int unused) {
 636             setExclusiveOwnerThread(null);
 637             setState(0);
 638             return true;
 639         }
 640 
 641         public void lock()        { acquire(1); }
 642         public boolean tryLock()  { return tryAcquire(1); }
 643         public void unlock()      { release(1); }
 644         public boolean isLocked() { return isHeldExclusively(); }
 645 
 646         void interruptIfStarted() {
 647             Thread t;
 648             if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
 649                 try {
 650                     t.interrupt();
 651                 } catch (SecurityException ignore) {
 652                 }
 653             }
 654         }
 655     }
 656 
 657     /*
 658      * Methods for setting control state
 659      */
 660 
 661     /**
 662      * Transitions runState to given target, or leaves it alone if
 663      * already at least the given target.
 664      *
 665      * @param targetState the desired state, either SHUTDOWN or STOP
 666      *        (but not TIDYING or TERMINATED -- use tryTerminate for that)
 667      */
 668     private void advanceRunState(int targetState) {
 669         for (;;) {
 670             int c = ctl.get();
 671             if (runStateAtLeast(c, targetState) ||
 672                 ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
 673                 break;
 674         }
 675     }
 676 
 677     /**
 678      * Transitions to TERMINATED state if either (SHUTDOWN and pool
 679      * and queue empty) or (STOP and pool empty).  If otherwise
 680      * eligible to terminate but workerCount is nonzero, interrupts an
 681      * idle worker to ensure that shutdown signals propagate. This
 682      * method must be called following any action that might make
 683      * termination possible -- reducing worker count or removing tasks
 684      * from the queue during shutdown. The method is non-private to
 685      * allow access from ScheduledThreadPoolExecutor.
 686      */
 687     final void tryTerminate() {
 688         for (;;) {
 689             int c = ctl.get();
 690             if (isRunning(c) ||
 691                 runStateAtLeast(c, TIDYING) ||
 692                 (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
 693                 return;
 694             if (workerCountOf(c) != 0) { // Eligible to terminate
 695                 interruptIdleWorkers(ONLY_ONE);
 696                 return;
 697             }
 698 
 699             final ReentrantLock mainLock = this.mainLock;
 700             mainLock.lock();
 701             try {
 702                 if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
 703                     try {
 704                         terminated();
 705                     } finally {
 706                         ctl.set(ctlOf(TERMINATED, 0));
 707                         termination.signalAll();
 708                     }
 709                     return;
 710                 }
 711             } finally {
 712                 mainLock.unlock();
 713             }
 714             // else retry on failed CAS
 715         }
 716     }
 717 
 718     /*
 719      * Methods for controlling interrupts to worker threads.
 720      */
 721 
 722     /**
 723      * If there is a security manager, makes sure caller has
 724      * permission to shut down threads in general (see shutdownPerm).
 725      * If this passes, additionally makes sure the caller is allowed
 726      * to interrupt each worker thread. This might not be true even if
 727      * first check passed, if the SecurityManager treats some threads
 728      * specially.
 729      */
 730     private void checkShutdownAccess() {
 731         SecurityManager security = System.getSecurityManager();
 732         if (security != null) {
 733             security.checkPermission(shutdownPerm);
 734             final ReentrantLock mainLock = this.mainLock;
 735             mainLock.lock();
 736             try {
 737                 for (Worker w : workers)
 738                     security.checkAccess(w.thread);
 739             } finally {
 740                 mainLock.unlock();
 741             }
 742         }
 743     }
 744 
 745     /**
 746      * Interrupts all threads, even if active. Ignores SecurityExceptions
 747      * (in which case some threads may remain uninterrupted).
 748      */
 749     private void interruptWorkers() {
 750         final ReentrantLock mainLock = this.mainLock;
 751         mainLock.lock();
 752         try {
 753             for (Worker w : workers)
 754                 w.interruptIfStarted();
 755         } finally {
 756             mainLock.unlock();
 757         }
 758     }
 759 
 760     /**
 761      * Interrupts threads that might be waiting for tasks (as
 762      * indicated by not being locked) so they can check for
 763      * termination or configuration changes. Ignores
 764      * SecurityExceptions (in which case some threads may remain
 765      * uninterrupted).
 766      *
 767      * @param onlyOne If true, interrupt at most one worker. This is
 768      * called only from tryTerminate when termination is otherwise
 769      * enabled but there are still other workers.  In this case, at
 770      * most one waiting worker is interrupted to propagate shutdown
 771      * signals in case all threads are currently waiting.
 772      * Interrupting any arbitrary thread ensures that newly arriving
 773      * workers since shutdown began will also eventually exit.
 774      * To guarantee eventual termination, it suffices to always
 775      * interrupt only one idle worker, but shutdown() interrupts all
 776      * idle workers so that redundant workers exit promptly, not
 777      * waiting for a straggler task to finish.
 778      */
 779     private void interruptIdleWorkers(boolean onlyOne) {
 780         final ReentrantLock mainLock = this.mainLock;
 781         mainLock.lock();
 782         try {
 783             for (Worker w : workers) {
 784                 Thread t = w.thread;
 785                 if (!t.isInterrupted() && w.tryLock()) {
 786                     try {
 787                         t.interrupt();
 788                     } catch (SecurityException ignore) {
 789                     } finally {
 790                         w.unlock();
 791                     }
 792                 }
 793                 if (onlyOne)
 794                     break;
 795             }
 796         } finally {
 797             mainLock.unlock();
 798         }
 799     }
 800 
 801     /**
 802      * Common form of interruptIdleWorkers, to avoid having to
 803      * remember what the boolean argument means.
 804      */
 805     private void interruptIdleWorkers() {
 806         interruptIdleWorkers(false);
 807     }
 808 
 809     private static final boolean ONLY_ONE = true;
 810 
 811     /*
 812      * Misc utilities, most of which are also exported to
 813      * ScheduledThreadPoolExecutor
 814      */
 815 
 816     /**
 817      * Invokes the rejected execution handler for the given command.
 818      * Package-protected for use by ScheduledThreadPoolExecutor.
 819      */
 820     final void reject(Runnable command) {
 821         handler.rejectedExecution(command, this);
 822     }
 823 
 824     /**
 825      * Performs any further cleanup following run state transition on
 826      * invocation of shutdown.  A no-op here, but used by
 827      * ScheduledThreadPoolExecutor to cancel delayed tasks.
 828      */
 829     void onShutdown() {
 830     }
 831 
 832     /**
 833      * State check needed by ScheduledThreadPoolExecutor to
 834      * enable running tasks during shutdown.
 835      *
 836      * @param shutdownOK true if should return true if SHUTDOWN
 837      */
 838     final boolean isRunningOrShutdown(boolean shutdownOK) {
 839         int rs = runStateOf(ctl.get());
 840         return rs == RUNNING || (rs == SHUTDOWN && shutdownOK);
 841     }
 842 
 843     /**
 844      * Drains the task queue into a new list, normally using
 845      * drainTo. But if the queue is a DelayQueue or any other kind of
 846      * queue for which poll or drainTo may fail to remove some
 847      * elements, it deletes them one by one.
 848      */
 849     private List<Runnable> drainQueue() {
 850         BlockingQueue<Runnable> q = workQueue;
 851         List<Runnable> taskList = new ArrayList<Runnable>();
 852         q.drainTo(taskList);
 853         if (!q.isEmpty()) {
 854             for (Runnable r : q.toArray(new Runnable[0])) {
 855                 if (q.remove(r))
 856                     taskList.add(r);
 857             }
 858         }
 859         return taskList;
 860     }
 861 
 862     /*
 863      * Methods for creating, running and cleaning up after workers
 864      */
 865 
 866     /**
 867      * Checks if a new worker can be added with respect to current
 868      * pool state and the given bound (either core or maximum). If so,
 869      * the worker count is adjusted accordingly, and, if possible, a
 870      * new worker is created and started, running firstTask as its
 871      * first task. This method returns false if the pool is stopped or
 872      * eligible to shut down. It also returns false if the thread
 873      * factory fails to create a thread when asked.  If the thread
 874      * creation fails, either due to the thread factory returning
 875      * null, or due to an exception (typically OutOfMemoryError in
 876      * Thread#start), we roll back cleanly.
 877      *
 878      * @param firstTask the task the new thread should run first (or
 879      * null if none). Workers are created with an initial first task
 880      * (in method execute()) to bypass queuing when there are fewer
 881      * than corePoolSize threads (in which case we always start one),
 882      * or when the queue is full (in which case we must bypass queue).
 883      * Initially idle threads are usually created via
 884      * prestartCoreThread or to replace other dying workers.
 885      *
 886      * @param core if true use corePoolSize as bound, else
 887      * maximumPoolSize. (A boolean indicator is used here rather than a
 888      * value to ensure reads of fresh values after checking other pool
 889      * state).
 890      * @return true if successful
 891      */
 892     private boolean addWorker(Runnable firstTask, boolean core) {
 893         retry:
 894         for (;;) {
 895             int c = ctl.get();
 896             int rs = runStateOf(c);
 897 
 898             // Check if queue empty only if necessary.
 899             if (rs >= SHUTDOWN &&
 900                 ! (rs == SHUTDOWN &&
 901                    firstTask == null &&
 902                    ! workQueue.isEmpty()))
 903                 return false;
 904 
 905             for (;;) {
 906                 int wc = workerCountOf(c);
 907                 if (wc >= CAPACITY ||
 908                     wc >= (core ? corePoolSize : maximumPoolSize))
 909                     return false;
 910                 if (compareAndIncrementWorkerCount(c))
 911                     break retry;
 912                 c = ctl.get();  // Re-read ctl
 913                 if (runStateOf(c) != rs)
 914                     continue retry;
 915                 // else CAS failed due to workerCount change; retry inner loop
 916             }
 917         }
 918 
 919         boolean workerStarted = false;
 920         boolean workerAdded = false;
 921         Worker w = null;
 922         try {
 923             final ReentrantLock mainLock = this.mainLock;
 924             w = new Worker(firstTask);
 925             final Thread t = w.thread;
 926             if (t != null) {
 927                 mainLock.lock();
 928                 try {
 929                     // Recheck while holding lock.
 930                     // Back out on ThreadFactory failure or if
 931                     // shut down before lock acquired.
 932                     int c = ctl.get();
 933                     int rs = runStateOf(c);
 934 
 935                     if (rs < SHUTDOWN ||
 936                         (rs == SHUTDOWN && firstTask == null)) {
 937                         if (t.isAlive()) // precheck that t is startable
 938                             throw new IllegalThreadStateException();
 939                         workers.add(w);
 940                         int s = workers.size();
 941                         if (s > largestPoolSize)
 942                             largestPoolSize = s;
 943                         workerAdded = true;
 944                     }
 945                 } finally {
 946                     mainLock.unlock();
 947                 }
 948                 if (workerAdded) {
 949                     t.start();
 950                     workerStarted = true;
 951                 }
 952             }
 953         } finally {
 954             if (! workerStarted)
 955                 addWorkerFailed(w);
 956         }
 957         return workerStarted;
 958     }
 959 
 960     /**
 961      * Rolls back the worker thread creation.
 962      * - removes worker from workers, if present
 963      * - decrements worker count
 964      * - rechecks for termination, in case the existence of this
 965      *   worker was holding up termination
 966      */
 967     private void addWorkerFailed(Worker w) {
 968         final ReentrantLock mainLock = this.mainLock;
 969         mainLock.lock();
 970         try {
 971             if (w != null)
 972                 workers.remove(w);
 973             decrementWorkerCount();
 974             tryTerminate();
 975         } finally {
 976             mainLock.unlock();
 977         }
 978     }
 979 
 980     /**
 981      * Performs cleanup and bookkeeping for a dying worker. Called
 982      * only from worker threads. Unless completedAbruptly is set,
 983      * assumes that workerCount has already been adjusted to account
 984      * for exit.  This method removes thread from worker set, and
 985      * possibly terminates the pool or replaces the worker if either
 986      * it exited due to user task exception or if fewer than
 987      * corePoolSize workers are running or queue is non-empty but
 988      * there are no workers.
 989      *
 990      * @param w the worker
 991      * @param completedAbruptly if the worker died due to user exception
 992      */
 993     private void processWorkerExit(Worker w, boolean completedAbruptly) {
 994         if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
 995             decrementWorkerCount();
 996 
 997         final ReentrantLock mainLock = this.mainLock;
 998         mainLock.lock();
 999         try {
1000             completedTaskCount += w.completedTasks;
1001             workers.remove(w);
1002         } finally {
1003             mainLock.unlock();
1004         }
1005 
1006         tryTerminate();
1007 
1008         int c = ctl.get();
1009         if (runStateLessThan(c, STOP)) {
1010             if (!completedAbruptly) {
1011                 int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
1012                 if (min == 0 && ! workQueue.isEmpty())
1013                     min = 1;
1014                 if (workerCountOf(c) >= min)
1015                     return; // replacement not needed
1016             }
1017             addWorker(null, false);
1018         }
1019     }
1020 
1021     /**
1022      * Performs blocking or timed wait for a task, depending on
1023      * current configuration settings, or returns null if this worker
1024      * must exit because of any of:
1025      * 1. There are more than maximumPoolSize workers (due to
1026      *    a call to setMaximumPoolSize).
1027      * 2. The pool is stopped.
1028      * 3. The pool is shutdown and the queue is empty.
1029      * 4. This worker timed out waiting for a task, and timed-out
1030      *    workers are subject to termination (that is,
1031      *    {@code allowCoreThreadTimeOut || workerCount > corePoolSize})
1032      *    both before and after the timed wait.
1033      *
1034      * @return task, or null if the worker must exit, in which case
1035      *         workerCount is decremented
1036      */
1037     private Runnable getTask() {
1038         boolean timedOut = false; // Did the last poll() time out?
1039 
1040         retry:
1041         for (;;) {
1042             int c = ctl.get();
1043             int rs = runStateOf(c);
1044 
1045             // Check if queue empty only if necessary.
1046             if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
1047                 decrementWorkerCount();
1048                 return null;
1049             }
1050 
1051             boolean timed;      // Are workers subject to culling?
1052 
1053             for (;;) {
1054                 int wc = workerCountOf(c);
1055                 timed = allowCoreThreadTimeOut || wc > corePoolSize;
1056 
1057                 if (wc <= maximumPoolSize && ! (timedOut && timed))
1058                     break;
1059                 if (compareAndDecrementWorkerCount(c))
1060                     return null;
1061                 c = ctl.get();  // Re-read ctl
1062                 if (runStateOf(c) != rs)
1063                     continue retry;
1064                 // else CAS failed due to workerCount change; retry inner loop
1065             }
1066 
1067             try {
1068                 Runnable r = timed ?
1069                     workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
1070                     workQueue.take();
1071                 if (r != null)
1072                     return r;
1073                 timedOut = true;
1074             } catch (InterruptedException retry) {
1075                 timedOut = false;
1076             }
1077         }
1078     }
1079 
1080     /**
1081      * Main worker run loop.  Repeatedly gets tasks from queue and
1082      * executes them, while coping with a number of issues:
1083      *
1084      * 1. We may start out with an initial task, in which case we
1085      * don't need to get the first one. Otherwise, as long as pool is
1086      * running, we get tasks from getTask. If it returns null then the
1087      * worker exits due to changed pool state or configuration
1088      * parameters.  Other exits result from exception throws in
1089      * external code, in which case completedAbruptly holds, which
1090      * usually leads processWorkerExit to replace this thread.
1091      *
1092      * 2. Before running any task, the lock is acquired to prevent
1093      * other pool interrupts while the task is executing, and
1094      * clearInterruptsForTaskRun called to ensure that unless pool is
1095      * stopping, this thread does not have its interrupt set.
1096      *
1097      * 3. Each task run is preceded by a call to beforeExecute, which
1098      * might throw an exception, in which case we cause thread to die
1099      * (breaking loop with completedAbruptly true) without processing
1100      * the task.
1101      *
1102      * 4. Assuming beforeExecute completes normally, we run the task,
1103      * gathering any of its thrown exceptions to send to
1104      * afterExecute. We separately handle RuntimeException, Error
1105      * (both of which the specs guarantee that we trap) and arbitrary
1106      * Throwables.  Because we cannot rethrow Throwables within
1107      * Runnable.run, we wrap them within Errors on the way out (to the
1108      * thread's UncaughtExceptionHandler).  Any thrown exception also
1109      * conservatively causes thread to die.
1110      *
1111      * 5. After task.run completes, we call afterExecute, which may
1112      * also throw an exception, which will also cause thread to
1113      * die. According to JLS Sec 14.20, this exception is the one that
1114      * will be in effect even if task.run throws.
1115      *
1116      * The net effect of the exception mechanics is that afterExecute
1117      * and the thread's UncaughtExceptionHandler have as accurate
1118      * information as we can provide about any problems encountered by
1119      * user code.
1120      *
1121      * @param w the worker
1122      */
1123     final void runWorker(Worker w) {
1124         Thread wt = Thread.currentThread();
1125         Runnable task = w.firstTask;
1126         w.firstTask = null;
1127         w.unlock(); // allow interrupts
1128         boolean completedAbruptly = true;
1129         try {
1130             while (task != null || (task = getTask()) != null) {
1131                 w.lock();
1132                 // If pool is stopping, ensure thread is interrupted;
1133                 // if not, ensure thread is not interrupted.  This
1134                 // requires a recheck in second case to deal with
1135                 // shutdownNow race while clearing interrupt
1136                 if ((runStateAtLeast(ctl.get(), STOP) ||
1137                      (Thread.interrupted() &&
1138                       runStateAtLeast(ctl.get(), STOP))) &&
1139                     !wt.isInterrupted())
1140                     wt.interrupt();
1141                 try {
1142                     beforeExecute(wt, task);
1143                     Throwable thrown = null;
1144                     try {
1145                         task.run();
1146                     } catch (RuntimeException x) {
1147                         thrown = x; throw x;
1148                     } catch (Error x) {
1149                         thrown = x; throw x;
1150                     } catch (Throwable x) {
1151                         thrown = x; throw new Error(x);
1152                     } finally {
1153                         afterExecute(task, thrown);
1154                     }
1155                 } finally {
1156                     task = null;
1157                     w.completedTasks++;
1158                     w.unlock();
1159                 }
1160             }
1161             completedAbruptly = false;
1162         } finally {
1163             processWorkerExit(w, completedAbruptly);
1164         }
1165     }
1166 
1167     // Public constructors and methods
1168 
1169     /**
1170      * Creates a new {@code ThreadPoolExecutor} with the given initial
1171      * parameters and default thread factory and rejected execution handler.
1172      * It may be more convenient to use one of the {@link Executors} factory
1173      * methods instead of this general purpose constructor.
1174      *
1175      * @param corePoolSize the number of threads to keep in the pool, even
1176      *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
1177      * @param maximumPoolSize the maximum number of threads to allow in the
1178      *        pool
1179      * @param keepAliveTime when the number of threads is greater than
1180      *        the core, this is the maximum time that excess idle threads
1181      *        will wait for new tasks before terminating.
1182      * @param unit the time unit for the {@code keepAliveTime} argument
1183      * @param workQueue the queue to use for holding tasks before they are
1184      *        executed.  This queue will hold only the {@code Runnable}
1185      *        tasks submitted by the {@code execute} method.
1186      * @throws IllegalArgumentException if one of the following holds:<br>
1187      *         {@code corePoolSize < 0}<br>
1188      *         {@code keepAliveTime < 0}<br>
1189      *         {@code maximumPoolSize <= 0}<br>
1190      *         {@code maximumPoolSize < corePoolSize}
1191      * @throws NullPointerException if {@code workQueue} is null
1192      */
1193     public ThreadPoolExecutor(int corePoolSize,
1194                               int maximumPoolSize,
1195                               long keepAliveTime,
1196                               TimeUnit unit,
1197                               BlockingQueue<Runnable> workQueue) {
1198         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
1199              Executors.defaultThreadFactory(), defaultHandler);
1200     }
1201 
1202     /**
1203      * Creates a new {@code ThreadPoolExecutor} with the given initial
1204      * parameters and default rejected execution handler.
1205      *
1206      * @param corePoolSize the number of threads to keep in the pool, even
1207      *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
1208      * @param maximumPoolSize the maximum number of threads to allow in the
1209      *        pool
1210      * @param keepAliveTime when the number of threads is greater than
1211      *        the core, this is the maximum time that excess idle threads
1212      *        will wait for new tasks before terminating.
1213      * @param unit the time unit for the {@code keepAliveTime} argument
1214      * @param workQueue the queue to use for holding tasks before they are
1215      *        executed.  This queue will hold only the {@code Runnable}
1216      *        tasks submitted by the {@code execute} method.
1217      * @param threadFactory the factory to use when the executor
1218      *        creates a new thread
1219      * @throws IllegalArgumentException if one of the following holds:<br>
1220      *         {@code corePoolSize < 0}<br>
1221      *         {@code keepAliveTime < 0}<br>
1222      *         {@code maximumPoolSize <= 0}<br>
1223      *         {@code maximumPoolSize < corePoolSize}
1224      * @throws NullPointerException if {@code workQueue}
1225      *         or {@code threadFactory} is null
1226      */
1227     public ThreadPoolExecutor(int corePoolSize,
1228                               int maximumPoolSize,
1229                               long keepAliveTime,
1230                               TimeUnit unit,
1231                               BlockingQueue<Runnable> workQueue,
1232                               ThreadFactory threadFactory) {
1233         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
1234              threadFactory, defaultHandler);
1235     }
1236 
1237     /**
1238      * Creates a new {@code ThreadPoolExecutor} with the given initial
1239      * parameters and default thread factory.
1240      *
1241      * @param corePoolSize the number of threads to keep in the pool, even
1242      *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
1243      * @param maximumPoolSize the maximum number of threads to allow in the
1244      *        pool
1245      * @param keepAliveTime when the number of threads is greater than
1246      *        the core, this is the maximum time that excess idle threads
1247      *        will wait for new tasks before terminating.
1248      * @param unit the time unit for the {@code keepAliveTime} argument
1249      * @param workQueue the queue to use for holding tasks before they are
1250      *        executed.  This queue will hold only the {@code Runnable}
1251      *        tasks submitted by the {@code execute} method.
1252      * @param handler the handler to use when execution is blocked
1253      *        because the thread bounds and queue capacities are reached
1254      * @throws IllegalArgumentException if one of the following holds:<br>
1255      *         {@code corePoolSize < 0}<br>
1256      *         {@code keepAliveTime < 0}<br>
1257      *         {@code maximumPoolSize <= 0}<br>
1258      *         {@code maximumPoolSize < corePoolSize}
1259      * @throws NullPointerException if {@code workQueue}
1260      *         or {@code handler} is null
1261      */
1262     public ThreadPoolExecutor(int corePoolSize,
1263                               int maximumPoolSize,
1264                               long keepAliveTime,
1265                               TimeUnit unit,
1266                               BlockingQueue<Runnable> workQueue,
1267                               RejectedExecutionHandler handler) {
1268         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
1269              Executors.defaultThreadFactory(), handler);
1270     }
1271 
1272     /**
1273      * Creates a new {@code ThreadPoolExecutor} with the given initial
1274      * parameters.
1275      *
1276      * @param corePoolSize the number of threads to keep in the pool, even
1277      *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
1278      * @param maximumPoolSize the maximum number of threads to allow in the
1279      *        pool
1280      * @param keepAliveTime when the number of threads is greater than
1281      *        the core, this is the maximum time that excess idle threads
1282      *        will wait for new tasks before terminating.
1283      * @param unit the time unit for the {@code keepAliveTime} argument
1284      * @param workQueue the queue to use for holding tasks before they are
1285      *        executed.  This queue will hold only the {@code Runnable}
1286      *        tasks submitted by the {@code execute} method.
1287      * @param threadFactory the factory to use when the executor
1288      *        creates a new thread
1289      * @param handler the handler to use when execution is blocked
1290      *        because the thread bounds and queue capacities are reached
1291      * @throws IllegalArgumentException if one of the following holds:<br>
1292      *         {@code corePoolSize < 0}<br>
1293      *         {@code keepAliveTime < 0}<br>
1294      *         {@code maximumPoolSize <= 0}<br>
1295      *         {@code maximumPoolSize < corePoolSize}
1296      * @throws NullPointerException if {@code workQueue}
1297      *         or {@code threadFactory} or {@code handler} is null
1298      */
1299     public ThreadPoolExecutor(int corePoolSize,
1300                               int maximumPoolSize,
1301                               long keepAliveTime,
1302                               TimeUnit unit,
1303                               BlockingQueue<Runnable> workQueue,
1304                               ThreadFactory threadFactory,
1305                               RejectedExecutionHandler handler) {
1306         if (corePoolSize < 0 ||
1307             maximumPoolSize <= 0 ||
1308             maximumPoolSize < corePoolSize ||
1309             keepAliveTime < 0)
1310             throw new IllegalArgumentException();
1311         if (workQueue == null || threadFactory == null || handler == null)
1312             throw new NullPointerException();
1313         this.corePoolSize = corePoolSize;
1314         this.maximumPoolSize = maximumPoolSize;
1315         this.workQueue = workQueue;
1316         this.keepAliveTime = unit.toNanos(keepAliveTime);
1317         this.threadFactory = threadFactory;
1318         this.handler = handler;
1319     }
1320 
1321     /**
1322      * Executes the given task sometime in the future.  The task
1323      * may execute in a new thread or in an existing pooled thread.
1324      *
1325      * If the task cannot be submitted for execution, either because this
1326      * executor has been shutdown or because its capacity has been reached,
1327      * the task is handled by the current {@code RejectedExecutionHandler}.
1328      *
1329      * @param command the task to execute
1330      * @throws RejectedExecutionException at discretion of
1331      *         {@code RejectedExecutionHandler}, if the task
1332      *         cannot be accepted for execution
1333      * @throws NullPointerException if {@code command} is null
1334      */
1335     public void execute(Runnable command) {
1336         if (command == null)
1337             throw new NullPointerException();
1338         /*
1339          * Proceed in 3 steps:
1340          *
1341          * 1. If fewer than corePoolSize threads are running, try to
1342          * start a new thread with the given command as its first
1343          * task.  The call to addWorker atomically checks runState and
1344          * workerCount, and so prevents false alarms that would add
1345          * threads when it shouldn't, by returning false.
1346          *
1347          * 2. If a task can be successfully queued, then we still need
1348          * to double-check whether we should have added a thread
1349          * (because existing ones died since last checking) or that
1350          * the pool shut down since entry into this method. So we
1351          * recheck state and if necessary roll back the enqueuing if
1352          * stopped, or start a new thread if there are none.
1353          *
1354          * 3. If we cannot queue task, then we try to add a new
1355          * thread.  If it fails, we know we are shut down or saturated
1356          * and so reject the task.
1357          */
1358         int c = ctl.get();
1359         if (workerCountOf(c) < corePoolSize) {
1360             if (addWorker(command, true))
1361                 return;
1362             c = ctl.get();
1363         }
1364         if (isRunning(c) && workQueue.offer(command)) {
1365             int recheck = ctl.get();
1366             if (! isRunning(recheck) && remove(command))
1367                 reject(command);
1368             else if (workerCountOf(recheck) == 0)
1369                 addWorker(null, false);
1370         }
1371         else if (!addWorker(command, false))
1372             reject(command);
1373     }
1374 
1375     /**
1376      * Initiates an orderly shutdown in which previously submitted
1377      * tasks are executed, but no new tasks will be accepted.
1378      * Invocation has no additional effect if already shut down.
1379      *
1380      * <p>This method does not wait for previously submitted tasks to
1381      * complete execution.  Use {@link #awaitTermination awaitTermination}
1382      * to do that.
1383      *
1384      * @throws SecurityException {@inheritDoc}
1385      */
1386     public void shutdown() {
1387         final ReentrantLock mainLock = this.mainLock;
1388         mainLock.lock();
1389         try {
1390             checkShutdownAccess();
1391             advanceRunState(SHUTDOWN);
1392             interruptIdleWorkers();
1393             onShutdown(); // hook for ScheduledThreadPoolExecutor
1394         } finally {
1395             mainLock.unlock();
1396         }
1397         tryTerminate();
1398     }
1399 
1400     /**
1401      * Attempts to stop all actively executing tasks, halts the
1402      * processing of waiting tasks, and returns a list of the tasks
1403      * that were awaiting execution. These tasks are drained (removed)
1404      * from the task queue upon return from this method.
1405      *
1406      * <p>This method does not wait for actively executing tasks to
1407      * terminate.  Use {@link #awaitTermination awaitTermination} to
1408      * do that.
1409      *
1410      * <p>There are no guarantees beyond best-effort attempts to stop
1411      * processing actively executing tasks.  This implementation
1412      * cancels tasks via {@link Thread#interrupt}, so any task that
1413      * fails to respond to interrupts may never terminate.
1414      *
1415      * @throws SecurityException {@inheritDoc}
1416      */
1417     public List<Runnable> shutdownNow() {
1418         List<Runnable> tasks;
1419         final ReentrantLock mainLock = this.mainLock;
1420         mainLock.lock();
1421         try {
1422             checkShutdownAccess();
1423             advanceRunState(STOP);
1424             interruptWorkers();
1425             tasks = drainQueue();
1426         } finally {
1427             mainLock.unlock();
1428         }
1429         tryTerminate();
1430         return tasks;
1431     }
1432 
1433     public boolean isShutdown() {
1434         return ! isRunning(ctl.get());
1435     }
1436 
1437     /**
1438      * Returns true if this executor is in the process of terminating
1439      * after {@link #shutdown} or {@link #shutdownNow} but has not
1440      * completely terminated.  This method may be useful for
1441      * debugging. A return of {@code true} reported a sufficient
1442      * period after shutdown may indicate that submitted tasks have
1443      * ignored or suppressed interruption, causing this executor not
1444      * to properly terminate.
1445      *
1446      * @return true if terminating but not yet terminated
1447      */
1448     public boolean isTerminating() {
1449         int c = ctl.get();
1450         return ! isRunning(c) && runStateLessThan(c, TERMINATED);
1451     }
1452 
1453     public boolean isTerminated() {
1454         return runStateAtLeast(ctl.get(), TERMINATED);
1455     }
1456 
1457     public boolean awaitTermination(long timeout, TimeUnit unit)
1458         throws InterruptedException {
1459         long nanos = unit.toNanos(timeout);
1460         final ReentrantLock mainLock = this.mainLock;
1461         mainLock.lock();
1462         try {
1463             for (;;) {
1464                 if (runStateAtLeast(ctl.get(), TERMINATED))
1465                     return true;
1466                 if (nanos <= 0)
1467                     return false;
1468                 nanos = termination.awaitNanos(nanos);
1469             }
1470         } finally {
1471             mainLock.unlock();
1472         }
1473     }
1474 
1475     /**
1476      * Invokes {@code shutdown} when this executor is no longer
1477      * referenced and it has no threads.
1478      */
1479     protected void finalize() {
1480         shutdown();
1481     }
1482 
1483     /**
1484      * Sets the thread factory used to create new threads.
1485      *
1486      * @param threadFactory the new thread factory
1487      * @throws NullPointerException if threadFactory is null
1488      * @see #getThreadFactory
1489      */
1490     public void setThreadFactory(ThreadFactory threadFactory) {
1491         if (threadFactory == null)
1492             throw new NullPointerException();
1493         this.threadFactory = threadFactory;
1494     }
1495 
1496     /**
1497      * Returns the thread factory used to create new threads.
1498      *
1499      * @return the current thread factory
1500      * @see #setThreadFactory
1501      */
1502     public ThreadFactory getThreadFactory() {
1503         return threadFactory;
1504     }
1505 
1506     /**
1507      * Sets a new handler for unexecutable tasks.
1508      *
1509      * @param handler the new handler
1510      * @throws NullPointerException if handler is null
1511      * @see #getRejectedExecutionHandler
1512      */
1513     public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
1514         if (handler == null)
1515             throw new NullPointerException();
1516         this.handler = handler;
1517     }
1518 
1519     /**
1520      * Returns the current handler for unexecutable tasks.
1521      *
1522      * @return the current handler
1523      * @see #setRejectedExecutionHandler
1524      */
1525     public RejectedExecutionHandler getRejectedExecutionHandler() {
1526         return handler;
1527     }
1528 
1529     /**
1530      * Sets the core number of threads.  This overrides any value set
1531      * in the constructor.  If the new value is smaller than the
1532      * current value, excess existing threads will be terminated when
1533      * they next become idle.  If larger, new threads will, if needed,
1534      * be started to execute any queued tasks.
1535      *
1536      * @param corePoolSize the new core size
1537      * @throws IllegalArgumentException if {@code corePoolSize < 0}
1538      * @see #getCorePoolSize
1539      */
1540     public void setCorePoolSize(int corePoolSize) {
1541         if (corePoolSize < 0)
1542             throw new IllegalArgumentException();
1543         int delta = corePoolSize - this.corePoolSize;
1544         this.corePoolSize = corePoolSize;
1545         if (workerCountOf(ctl.get()) > corePoolSize)
1546             interruptIdleWorkers();
1547         else if (delta > 0) {
1548             // We don't really know how many new threads are "needed".
1549             // As a heuristic, prestart enough new workers (up to new
1550             // core size) to handle the current number of tasks in
1551             // queue, but stop if queue becomes empty while doing so.
1552             int k = Math.min(delta, workQueue.size());
1553             while (k-- > 0 && addWorker(null, true)) {
1554                 if (workQueue.isEmpty())
1555                     break;
1556             }
1557         }
1558     }
1559 
1560     /**
1561      * Returns the core number of threads.
1562      *
1563      * @return the core number of threads
1564      * @see #setCorePoolSize
1565      */
1566     public int getCorePoolSize() {
1567         return corePoolSize;
1568     }
1569 
1570     /**
1571      * Starts a core thread, causing it to idly wait for work. This
1572      * overrides the default policy of starting core threads only when
1573      * new tasks are executed. This method will return {@code false}
1574      * if all core threads have already been started.
1575      *
1576      * @return {@code true} if a thread was started
1577      */
1578     public boolean prestartCoreThread() {
1579         return workerCountOf(ctl.get()) < corePoolSize &&
1580             addWorker(null, true);
1581     }
1582 
1583     /**
1584      * Same as prestartCoreThread except arranges that at least one
1585      * thread is started even if corePoolSize is 0.
1586      */
1587     void ensurePrestart() {
1588         int wc = workerCountOf(ctl.get());
1589         if (wc < corePoolSize)
1590             addWorker(null, true);
1591         else if (wc == 0)
1592             addWorker(null, false);
1593     }
1594 
1595     /**
1596      * Starts all core threads, causing them to idly wait for work. This
1597      * overrides the default policy of starting core threads only when
1598      * new tasks are executed.
1599      *
1600      * @return the number of threads started
1601      */
1602     public int prestartAllCoreThreads() {
1603         int n = 0;
1604         while (addWorker(null, true))
1605             ++n;
1606         return n;
1607     }
1608 
1609     /**
1610      * Returns true if this pool allows core threads to time out and
1611      * terminate if no tasks arrive within the keepAlive time, being
1612      * replaced if needed when new tasks arrive. When true, the same
1613      * keep-alive policy applying to non-core threads applies also to
1614      * core threads. When false (the default), core threads are never
1615      * terminated due to lack of incoming tasks.
1616      *
1617      * @return {@code true} if core threads are allowed to time out,
1618      *         else {@code false}
1619      *
1620      * @since 1.6
1621      */
1622     public boolean allowsCoreThreadTimeOut() {
1623         return allowCoreThreadTimeOut;
1624     }
1625 
1626     /**
1627      * Sets the policy governing whether core threads may time out and
1628      * terminate if no tasks arrive within the keep-alive time, being
1629      * replaced if needed when new tasks arrive. When false, core
1630      * threads are never terminated due to lack of incoming
1631      * tasks. When true, the same keep-alive policy applying to
1632      * non-core threads applies also to core threads. To avoid
1633      * continual thread replacement, the keep-alive time must be
1634      * greater than zero when setting {@code true}. This method
1635      * should in general be called before the pool is actively used.
1636      *
1637      * @param value {@code true} if should time out, else {@code false}
1638      * @throws IllegalArgumentException if value is {@code true}
1639      *         and the current keep-alive time is not greater than zero
1640      *
1641      * @since 1.6
1642      */
1643     public void allowCoreThreadTimeOut(boolean value) {
1644         if (value && keepAliveTime <= 0)
1645             throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
1646         if (value != allowCoreThreadTimeOut) {
1647             allowCoreThreadTimeOut = value;
1648             if (value)
1649                 interruptIdleWorkers();
1650         }
1651     }
1652 
1653     /**
1654      * Sets the maximum allowed number of threads. This overrides any
1655      * value set in the constructor. If the new value is smaller than
1656      * the current value, excess existing threads will be
1657      * terminated when they next become idle.
1658      *
1659      * @param maximumPoolSize the new maximum
1660      * @throws IllegalArgumentException if the new maximum is
1661      *         less than or equal to zero, or
1662      *         less than the {@linkplain #getCorePoolSize core pool size}
1663      * @see #getMaximumPoolSize
1664      */
1665     public void setMaximumPoolSize(int maximumPoolSize) {
1666         if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
1667             throw new IllegalArgumentException();
1668         this.maximumPoolSize = maximumPoolSize;
1669         if (workerCountOf(ctl.get()) > maximumPoolSize)
1670             interruptIdleWorkers();
1671     }
1672 
1673     /**
1674      * Returns the maximum allowed number of threads.
1675      *
1676      * @return the maximum allowed number of threads
1677      * @see #setMaximumPoolSize
1678      */
1679     public int getMaximumPoolSize() {
1680         return maximumPoolSize;
1681     }
1682 
1683     /**
1684      * Sets the time limit for which threads may remain idle before
1685      * being terminated.  If there are more than the core number of
1686      * threads currently in the pool, after waiting this amount of
1687      * time without processing a task, excess threads will be
1688      * terminated.  This overrides any value set in the constructor.
1689      *
1690      * @param time the time to wait.  A time value of zero will cause
1691      *        excess threads to terminate immediately after executing tasks.
1692      * @param unit the time unit of the {@code time} argument
1693      * @throws IllegalArgumentException if {@code time} less than zero or
1694      *         if {@code time} is zero and {@code allowsCoreThreadTimeOut}
1695      * @see #getKeepAliveTime
1696      */
1697     public void setKeepAliveTime(long time, TimeUnit unit) {
1698         if (time < 0)
1699             throw new IllegalArgumentException();
1700         if (time == 0 && allowsCoreThreadTimeOut())
1701             throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
1702         long keepAliveTime = unit.toNanos(time);
1703         long delta = keepAliveTime - this.keepAliveTime;
1704         this.keepAliveTime = keepAliveTime;
1705         if (delta < 0)
1706             interruptIdleWorkers();
1707     }
1708 
1709     /**
1710      * Returns the thread keep-alive time, which is the amount of time
1711      * that threads in excess of the core pool size may remain
1712      * idle before being terminated.
1713      *
1714      * @param unit the desired time unit of the result
1715      * @return the time limit
1716      * @see #setKeepAliveTime
1717      */
1718     public long getKeepAliveTime(TimeUnit unit) {
1719         return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
1720     }
1721 
1722     /* User-level queue utilities */
1723 
1724     /**
1725      * Returns the task queue used by this executor. Access to the
1726      * task queue is intended primarily for debugging and monitoring.
1727      * This queue may be in active use.  Retrieving the task queue
1728      * does not prevent queued tasks from executing.
1729      *
1730      * @return the task queue
1731      */
1732     public BlockingQueue<Runnable> getQueue() {
1733         return workQueue;
1734     }
1735 
1736     /**
1737      * Removes this task from the executor's internal queue if it is
1738      * present, thus causing it not to be run if it has not already
1739      * started.
1740      *
1741      * <p> This method may be useful as one part of a cancellation
1742      * scheme.  It may fail to remove tasks that have been converted
1743      * into other forms before being placed on the internal queue. For
1744      * example, a task entered using {@code submit} might be
1745      * converted into a form that maintains {@code Future} status.
1746      * However, in such cases, method {@link #purge} may be used to
1747      * remove those Futures that have been cancelled.
1748      *
1749      * @param task the task to remove
1750      * @return true if the task was removed
1751      */
1752     public boolean remove(Runnable task) {
1753         boolean removed = workQueue.remove(task);
1754         tryTerminate(); // In case SHUTDOWN and now empty
1755         return removed;
1756     }
1757 
1758     /**
1759      * Tries to remove from the work queue all {@link Future}
1760      * tasks that have been cancelled. This method can be useful as a
1761      * storage reclamation operation, that has no other impact on
1762      * functionality. Cancelled tasks are never executed, but may
1763      * accumulate in work queues until worker threads can actively
1764      * remove them. Invoking this method instead tries to remove them now.
1765      * However, this method may fail to remove tasks in
1766      * the presence of interference by other threads.
1767      */
1768     public void purge() {
1769         final BlockingQueue<Runnable> q = workQueue;
1770         try {
1771             Iterator<Runnable> it = q.iterator();
1772             while (it.hasNext()) {
1773                 Runnable r = it.next();
1774                 if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
1775                     it.remove();
1776             }
1777         } catch (ConcurrentModificationException fallThrough) {
1778             // Take slow path if we encounter interference during traversal.
1779             // Make copy for traversal and call remove for cancelled entries.
1780             // The slow path is more likely to be O(N*N).
1781             for (Object r : q.toArray())
1782                 if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
1783                     q.remove(r);
1784         }
1785 
1786         tryTerminate(); // In case SHUTDOWN and now empty
1787     }
1788 
1789     /* Statistics */
1790 
1791     /**
1792      * Returns the current number of threads in the pool.
1793      *
1794      * @return the number of threads
1795      */
1796     public int getPoolSize() {
1797         final ReentrantLock mainLock = this.mainLock;
1798         mainLock.lock();
1799         try {
1800             // Remove rare and surprising possibility of
1801             // isTerminated() && getPoolSize() > 0
1802             return runStateAtLeast(ctl.get(), TIDYING) ? 0
1803                 : workers.size();
1804         } finally {
1805             mainLock.unlock();
1806         }
1807     }
1808 
1809     /**
1810      * Returns the approximate number of threads that are actively
1811      * executing tasks.
1812      *
1813      * @return the number of threads
1814      */
1815     public int getActiveCount() {
1816         final ReentrantLock mainLock = this.mainLock;
1817         mainLock.lock();
1818         try {
1819             int n = 0;
1820             for (Worker w : workers)
1821                 if (w.isLocked())
1822                     ++n;
1823             return n;
1824         } finally {
1825             mainLock.unlock();
1826         }
1827     }
1828 
1829     /**
1830      * Returns the largest number of threads that have ever
1831      * simultaneously been in the pool.
1832      *
1833      * @return the number of threads
1834      */
1835     public int getLargestPoolSize() {
1836         final ReentrantLock mainLock = this.mainLock;
1837         mainLock.lock();
1838         try {
1839             return largestPoolSize;
1840         } finally {
1841             mainLock.unlock();
1842         }
1843     }
1844 
1845     /**
1846      * Returns the approximate total number of tasks that have ever been
1847      * scheduled for execution. Because the states of tasks and
1848      * threads may change dynamically during computation, the returned
1849      * value is only an approximation.
1850      *
1851      * @return the number of tasks
1852      */
1853     public long getTaskCount() {
1854         final ReentrantLock mainLock = this.mainLock;
1855         mainLock.lock();
1856         try {
1857             long n = completedTaskCount;
1858             for (Worker w : workers) {
1859                 n += w.completedTasks;
1860                 if (w.isLocked())
1861                     ++n;
1862             }
1863             return n + workQueue.size();
1864         } finally {
1865             mainLock.unlock();
1866         }
1867     }
1868 
1869     /**
1870      * Returns the approximate total number of tasks that have
1871      * completed execution. Because the states of tasks and threads
1872      * may change dynamically during computation, the returned value
1873      * is only an approximation, but one that does not ever decrease
1874      * across successive calls.
1875      *
1876      * @return the number of tasks
1877      */
1878     public long getCompletedTaskCount() {
1879         final ReentrantLock mainLock = this.mainLock;
1880         mainLock.lock();
1881         try {
1882             long n = completedTaskCount;
1883             for (Worker w : workers)
1884                 n += w.completedTasks;
1885             return n;
1886         } finally {
1887             mainLock.unlock();
1888         }
1889     }
1890 
1891     /**
1892      * Returns a string identifying this pool, as well as its state,
1893      * including indications of run state and estimated worker and
1894      * task counts.
1895      *
1896      * @return a string identifying this pool, as well as its state
1897      */
1898     public String toString() {
1899         long ncompleted;
1900         int nworkers, nactive;
1901         final ReentrantLock mainLock = this.mainLock;
1902         mainLock.lock();
1903         try {
1904             ncompleted = completedTaskCount;
1905             nactive = 0;
1906             nworkers = workers.size();
1907             for (Worker w : workers) {
1908                 ncompleted += w.completedTasks;
1909                 if (w.isLocked())
1910                     ++nactive;
1911             }
1912         } finally {
1913             mainLock.unlock();
1914         }
1915         int c = ctl.get();
1916         String rs = (runStateLessThan(c, SHUTDOWN) ? "Running" :
1917                      (runStateAtLeast(c, TERMINATED) ? "Terminated" :
1918                       "Shutting down"));
1919         return super.toString() +
1920             "[" + rs +
1921             ", pool size = " + nworkers +
1922             ", active threads = " + nactive +
1923             ", queued tasks = " + workQueue.size() +
1924             ", completed tasks = " + ncompleted +
1925             "]";
1926     }
1927 
1928     /* Extension hooks */
1929 
1930     /**
1931      * Method invoked prior to executing the given Runnable in the
1932      * given thread.  This method is invoked by thread {@code t} that
1933      * will execute task {@code r}, and may be used to re-initialize
1934      * ThreadLocals, or to perform logging.
1935      *
1936      * <p>This implementation does nothing, but may be customized in
1937      * subclasses. Note: To properly nest multiple overridings, subclasses
1938      * should generally invoke {@code super.beforeExecute} at the end of
1939      * this method.
1940      *
1941      * @param t the thread that will run task {@code r}
1942      * @param r the task that will be executed
1943      */
1944     protected void beforeExecute(Thread t, Runnable r) { }
1945 
1946     /**
1947      * Method invoked upon completion of execution of the given Runnable.
1948      * This method is invoked by the thread that executed the task. If
1949      * non-null, the Throwable is the uncaught {@code RuntimeException}
1950      * or {@code Error} that caused execution to terminate abruptly.
1951      *
1952      * <p>This implementation does nothing, but may be customized in
1953      * subclasses. Note: To properly nest multiple overridings, subclasses
1954      * should generally invoke {@code super.afterExecute} at the
1955      * beginning of this method.
1956      *
1957      * <p><b>Note:</b> When actions are enclosed in tasks (such as
1958      * {@link FutureTask}) either explicitly or via methods such as
1959      * {@code submit}, these task objects catch and maintain
1960      * computational exceptions, and so they do not cause abrupt
1961      * termination, and the internal exceptions are <em>not</em>
1962      * passed to this method. If you would like to trap both kinds of
1963      * failures in this method, you can further probe for such cases,
1964      * as in this sample subclass that prints either the direct cause
1965      * or the underlying exception if a task has been aborted:
1966      *
1967      *  <pre> {@code
1968      * class ExtendedExecutor extends ThreadPoolExecutor {
1969      *   // ...
1970      *   protected void afterExecute(Runnable r, Throwable t) {
1971      *     super.afterExecute(r, t);
1972      *     if (t == null && r instanceof Future<?>) {
1973      *       try {
1974      *         Object result = ((Future<?>) r).get();
1975      *       } catch (CancellationException ce) {
1976      *           t = ce;
1977      *       } catch (ExecutionException ee) {
1978      *           t = ee.getCause();
1979      *       } catch (InterruptedException ie) {
1980      *           Thread.currentThread().interrupt(); // ignore/reset
1981      *       }
1982      *     }
1983      *     if (t != null)
1984      *       System.out.println(t);
1985      *   }
1986      * }}</pre>
1987      *
1988      * @param r the runnable that has completed
1989      * @param t the exception that caused termination, or null if
1990      * execution completed normally
1991      */
1992     protected void afterExecute(Runnable r, Throwable t) { }
1993 
1994     /**
1995      * Method invoked when the Executor has terminated.  Default
1996      * implementation does nothing. Note: To properly nest multiple
1997      * overridings, subclasses should generally invoke
1998      * {@code super.terminated} within this method.
1999      */
2000     protected void terminated() { }
2001 
2002     /* Predefined RejectedExecutionHandlers */
2003 
2004     /**
2005      * A handler for rejected tasks that runs the rejected task
2006      * directly in the calling thread of the {@code execute} method,
2007      * unless the executor has been shut down, in which case the task
2008      * is discarded.
2009      */
2010     public static class CallerRunsPolicy implements RejectedExecutionHandler {
2011         /**
2012          * Creates a {@code CallerRunsPolicy}.
2013          */
2014         public CallerRunsPolicy() { }
2015 
2016         /**
2017          * Executes task r in the caller's thread, unless the executor
2018          * has been shut down, in which case the task is discarded.
2019          *
2020          * @param r the runnable task requested to be executed
2021          * @param e the executor attempting to execute this task
2022          */
2023         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
2024             if (!e.isShutdown()) {
2025                 r.run();
2026             }
2027         }
2028     }
2029 
2030     /**
2031      * A handler for rejected tasks that throws a
2032      * {@code RejectedExecutionException}.
2033      */
2034     public static class AbortPolicy implements RejectedExecutionHandler {
2035         /**
2036          * Creates an {@code AbortPolicy}.
2037          */
2038         public AbortPolicy() { }
2039 
2040         /**
2041          * Always throws RejectedExecutionException.
2042          *
2043          * @param r the runnable task requested to be executed
2044          * @param e the executor attempting to execute this task
2045          * @throws RejectedExecutionException always.
2046          */
2047         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
2048             throw new RejectedExecutionException("Task " + r.toString() +
2049                                                  " rejected from " +
2050                                                  e.toString());
2051         }
2052     }
2053 
2054     /**
2055      * A handler for rejected tasks that silently discards the
2056      * rejected task.
2057      */
2058     public static class DiscardPolicy implements RejectedExecutionHandler {
2059         /**
2060          * Creates a {@code DiscardPolicy}.
2061          */
2062         public DiscardPolicy() { }
2063 
2064         /**
2065          * Does nothing, which has the effect of discarding task r.
2066          *
2067          * @param r the runnable task requested to be executed
2068          * @param e the executor attempting to execute this task
2069          */
2070         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
2071         }
2072     }
2073 
2074     /**
2075      * A handler for rejected tasks that discards the oldest unhandled
2076      * request and then retries {@code execute}, unless the executor
2077      * is shut down, in which case the task is discarded.
2078      */
2079     public static class DiscardOldestPolicy implements RejectedExecutionHandler {
2080         /**
2081          * Creates a {@code DiscardOldestPolicy} for the given executor.
2082          */
2083         public DiscardOldestPolicy() { }
2084 
2085         /**
2086          * Obtains and ignores the next task that the executor
2087          * would otherwise execute, if one is immediately available,
2088          * and then retries execution of task r, unless the executor
2089          * is shut down, in which case task r is instead discarded.
2090          *
2091          * @param r the runnable task requested to be executed
2092          * @param e the executor attempting to execute this task
2093          */
2094         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
2095             if (!e.isShutdown()) {
2096                 e.getQueue().poll();
2097                 e.execute(r);
2098             }
2099         }
2100     }
2101 }
View Code

 

线程池源码分析

(一) 创建“线程池”

下面以newFixedThreadPool()介绍线程池的创建过程。

1. newFixedThreadPool()

newFixedThreadPool()在Executors.java中定义,源码如下:

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

说明:newFixedThreadPool(int nThreads)的作用是创建一个线程池,线程池的容量是nThreads。
         newFixedThreadPool()在调用ThreadPoolExecutor()时,会传递一个LinkedBlockingQueue()对象,而LinkedBlockingQueue是单向链表实现的阻塞队列。在线程池中,就是通过该阻塞队列来实现"当线程池中任务数量超过允许的任务数量时,部分任务会阻塞等待"。
关于LinkedBlockingQueue的实现细节,读者可以参考"Java多线程系列--“JUC集合”08之 LinkedBlockingQueue"。

 

2. ThreadPoolExecutor()

ThreadPoolExecutor()在ThreadPoolExecutor.java中定义,源码如下:

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

说明:该函数实际上是调用ThreadPoolExecutor的另外一个构造函数。该函数的源码如下:

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    // 核心池大小
    this.corePoolSize = corePoolSize;
    // 最大池大小
    this.maximumPoolSize = maximumPoolSize;
    // 线程池的等待队列
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    // 线程工厂对象
    this.threadFactory = threadFactory;
    // 拒绝策略的句柄
    this.handler = handler;
}

说明:在ThreadPoolExecutor()的构造函数中,进行的是初始化工作。
corePoolSize, maximumPoolSize, unit, keepAliveTime和workQueue这些变量的值是已知的,它们都是通过newFixedThreadPool()传递而来。下面看看threadFactory和handler对象。

 

2.1 ThreadFactory

线程池中的ThreadFactory是一个线程工厂,线程池创建线程都是通过线程工厂对象(threadFactory)来完成的。
上面所说的threadFactory对象,是通过 Executors.defaultThreadFactory()返回的。Executors.java中的defaultThreadFactory()源码如下:

public static ThreadFactory defaultThreadFactory() {
    return new DefaultThreadFactory();
}

defaultThreadFactory()返回DefaultThreadFactory对象。Executors.java中的DefaultThreadFactory()源码如下:

 

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }

    // 提供创建线程的API。
    public Thread newThread(Runnable r) {
        // 线程对应的任务是Runnable对象r
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        // 设为“非守护线程”
        if (t.isDaemon())
            t.setDaemon(false);
        // 将优先级设为“Thread.NORM_PRIORITY”
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

 

说明:ThreadFactory的作用就是提供创建线程的功能的线程工厂。
         它是通过newThread()提供创建线程功能的,下面简单说说newThread()。newThread()创建的线程对应的任务是Runnable对象,它创建的线程都是“非守护线程”而且“线程优先级都是Thread.NORM_PRIORITY”。

 

2.2 RejectedExecutionHandler

handler是ThreadPoolExecutor中拒绝策略的处理句柄。所谓拒绝策略,是指将任务添加到线程池中时,线程池拒绝该任务所采取的相应策略。
线程池默认会采用的是defaultHandler策略,即AbortPolicy策略。在AbortPolicy策略中,线程池拒绝任务时会抛出异常!
defaultHandler的定义如下:

private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();

AbortPolicy的源码如下:

public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }

    // 抛出异常
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}

 

(二) 添加任务到“线程池”

1. execute()

execute()定义在ThreadPoolExecutor.java中,源码如下:

public void execute(Runnable command) {
    // 如果任务为null,则抛出异常。
    if (command == null)
        throw new NullPointerException();
    // 获取ctl对应的int值。该int值保存了"线程池中任务的数量"和"线程池状态"信息
    int c = ctl.get();
    // 当线程池中的任务数量 < "核心池大小"时,即线程池中少于corePoolSize个任务。
    // 则通过addWorker(command, true)新建一个线程,并将任务(command)添加到该线程中;然后,启动该线程从而执行任务。
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 当线程池中的任务数量 >= "核心池大小"时,
    // 而且,"线程池处于允许状态"时,则尝试将任务添加到阻塞队列中。
    if (isRunning(c) && workQueue.offer(command)) {
        // 再次确认“线程池状态”,若线程池异常终止了,则删除任务;然后通过reject()执行相应的拒绝策略的内容。
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 否则,如果"线程池中任务数量"为0,则通过addWorker(null, false)尝试新建一个线程,新建线程对应的任务为null。
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 通过addWorker(command, false)新建一个线程,并将任务(command)添加到该线程中;然后,启动该线程从而执行任务。
    // 如果addWorker(command, false)执行失败,则通过reject()执行相应的拒绝策略的内容。
    else if (!addWorker(command, false))
        reject(command);
}

说明:execute()的作用是将任务添加到线程池中执行。它会分为3种情况进行处理:
        情况1 -- 如果"线程池中任务数量" < "核心池大小"时,即线程池中少于corePoolSize个任务;此时就新建一个线程,并将该任务添加到线程中进行执行。
        情况2 -- 如果"线程池中任务数量" >= "核心池大小",并且"线程池是允许状态";此时,则将任务添加到阻塞队列中阻塞等待。在该情况下,会再次确认"线程池的状态",如果"第2次读到的线程池状态"和"第1次读到的线程池状态"不同,则从阻塞队列中删除该任务。
        情况3 -- 非以上两种情况。在这种情况下,尝试新建一个线程,并将该任务添加到线程中进行执行。如果执行失败,则通过reject()拒绝该任务。

 

2. addWorker()

addWorker()的源码如下:

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    // 更新"线程池状态和计数"标记,即更新ctl。
    for (;;) {
        // 获取ctl对应的int值。该int值保存了"线程池中任务的数量"和"线程池状态"信息
        int c = ctl.get();
        // 获取线程池状态。
        int rs = runStateOf(c);

        // 有效性检查
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        for (;;) {
            // 获取线程池中任务的数量。
            int wc = workerCountOf(c);
            // 如果"线程池中任务的数量"超过限制,则返回false。
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // 通过CAS函数将c的值+1。操作失败的话,则退出循环。
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            // 检查"线程池状态",如果与之前的状态不同,则从retry重新开始。
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    // 添加任务到线程池,并启动任务所在的线程。
    try {
        final ReentrantLock mainLock = this.mainLock;
        // 新建Worker,并且指定firstTask为Worker的第一个任务。
        w = new Worker(firstTask);
        // 获取Worker对应的线程。
        final Thread t = w.thread;
        if (t != null) {
            // 获取锁
            mainLock.lock();
            try {
                int c = ctl.get();
                int rs = runStateOf(c);

                // 再次确认"线程池状态"
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    // 将Worker对象(w)添加到"线程池的Worker集合(workers)"中
                    workers.add(w);
                    // 更新largestPoolSize
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                // 释放锁
                mainLock.unlock();
            }
            // 如果"成功将任务添加到线程池"中,则启动任务所在的线程。 
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    // 返回任务是否启动。
    return workerStarted;
}

说明
    addWorker(Runnable firstTask, boolean core) 的作用是将任务(firstTask)添加到线程池中,并启动该任务。
    core为true的话,则以corePoolSize为界限,若"线程池中已有任务数量>=corePoolSize",则返回false;core为false的话,则以maximumPoolSize为界限,若"线程池中已有任务数量>=maximumPoolSize",则返回false。
    addWorker()会先通过for循环不断尝试更新ctl状态,ctl记录了"线程池中任务数量和线程池状态"。
    更新成功之后,再通过try模块来将任务添加到线程池中,并启动任务所在的线程。

    从addWorker()中,我们能清晰的发现:线程池在添加任务时,会创建任务对应的Worker对象;而一个Workder对象包含一个Thread对象。(01) 通过将Worker对象添加到"线程的workers集合"中,从而实现将任务添加到线程池中。 (02) 通过启动Worker对应的Thread线程,则执行该任务。

 

3. submit()

补充说明一点,submit()实际上也是通过调用execute()实现的,源码如下:

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}

 

(三) 关闭“线程池”

shutdown()的源码如下:

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    // 获取锁
    mainLock.lock();
    try {
        // 检查终止线程池的“线程”是否有权限。
        checkShutdownAccess();
        // 设置线程池的状态为关闭状态。
        advanceRunState(SHUTDOWN);
        // 中断线程池中空闲的线程。
        interruptIdleWorkers();
        // 钩子函数,在ThreadPoolExecutor中没有任何动作。
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        // 释放锁
        mainLock.unlock();
    }
    // 尝试终止线程池
    tryTerminate();
}

说明:shutdown()的作用是关闭线程池。

 


更多内容

1. Java多线程系列目录(共xx篇)

2. Java多线程系列--“JUC线程池”01之 线程池架构

3. Java多线程系列--“JUC线程池”02之 线程池原理(一)

 

posted on 2014-02-10 08:59 如果天空不死 阅读(...) 评论(...) 编辑 收藏