Executors解析

ThreadPoolExecutor解析一（核心线程池数量、线程池状态等） ：
[url]http://donald-draper.iteye.com/blog/2366934[/url]
ThreadPoolExecutor解析二（线程工厂、工作线程，拒绝策略等）：
[url]http://donald-draper.iteye.com/blog/2367064[/url]
ThreadPoolExecutor解析三（线程池执行提交任务）：
[url]http://donald-draper.iteye.com/blog/2367199[/url]
ThreadPoolExecutor解析四（线程池关闭）：
[url]http://donald-draper.iteye.com/blog/2367246[/url]
ScheduledThreadPoolExecutor解析一（调度任务，任务队列）：
[url]http://donald-draper.iteye.com/blog/2367332[/url]
ScheduledThreadPoolExecutor解析二（任务调度）：
[url]http://donald-draper.iteye.com/blog/2367593[/url]
ScheduledThreadPoolExecutor解析三（关闭线程池）：
[url]http://donald-draper.iteye.com/blog/2367698[/url]

package java.util.concurrent;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;
import java.security.PrivilegedActionException;
import java.security.AccessControlException;
import sun.security.util.SecurityConstants;

/**
 * Factory and utility methods for {@link Executor}, {@link
 * ExecutorService}, {@link ScheduledExecutorService}, {@link
 * ThreadFactory}, and {@link Callable} classes defined in this
 * package. This class supports the following kinds of methods:
 *
Executors提供了工厂方法和有效方法为Executor，ExecutorService，
ScheduledExecutorService，ThreadFactory，Callable。提供一下方法:
 * [list]
 *   
 Methods that create and return an {@link ExecutorService}
 *        set up with commonly useful configuration settings.
      根据通用的配置参数，创建并返回一个ExecutorService
 *   
 Methods that create and return a {@link ScheduledExecutorService}
 *        set up with commonly useful configuration settings.
      根据通用的配置参数，创建并返回一个ScheduledExecutorService
 *   
 Methods that create and return a "wrapped" ExecutorService, that
 *        disables reconfiguration by making implementation-specific methods
 *        inaccessible.
      创建并返回一个包装的ExecutorService，不能重新配置
 *   
 Methods that create and return a {@link ThreadFactory}
 *        that sets newly created threads to a known state.
      创建并返回一个ThreadFactory，设置创建线程为指定状态
 *   
 Methods that create and return a {@link Callable}
 *        out of other closure-like forms, so they can be used
 *        in execution methods requiring Callable.
      创建并返回一个闭包形式的Callable，以便可以在执行方法中执行需要的形式的Callable。
 * [/list]
 *
 * @since 1.5
 * @author Doug Lea
 */
public class Executors {

    /**
     * Creates a thread pool that reuses a fixed number of threads
     * operating off a shared unbounded queue.  At any point, at most
     * nThreads threads will be active processing tasks.
     * If additional tasks are submitted when all threads are active,
     * they will wait in the queue until a thread is available.
     * If any thread terminates due to a failure during execution
     * prior to shutdown, a new one will take its place if needed to
     * execute subsequent tasks.  The threads in the pool will exist
     * until it is explicitly {@link ExecutorService#shutdown shutdown}.
     *
     创建一个可以重用的固定数量的工作线程和无界的共享队列的线程池。在任何时候，
     最多有nThreads个工作线程。如果所有的工作线程在执行任务，新提交的任务
     将会在任务队列中等待，直到有工作线程可利用。如果在线程池关闭之前，如果
     有任务在执行中失败并结束，需要的话，则一个新工作线程将会创建，替代旧的
     工作线程。直到线程池关闭，线程池中的工作线程才退出。
     * @param nThreads the number of threads in the pool
     * @return the newly created thread pool
     * @throws IllegalArgumentException if {@code nThreads <= 0}
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue());
    }
    //与上一个方法的区别增加了线程池参数ThreadFactory
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue(),
                                      threadFactory);
    }
     /**
     * Creates an Executor that uses a single worker thread operating
     * off an unbounded queue. (Note however that if this single
     * thread terminates due to a failure during execution prior to
     * shutdown, a new one will take its place if needed to execute
     * subsequent tasks.)  Tasks are guaranteed to execute
     * sequentially, and no more than one task will be active at any
     * given time. Unlike the otherwise equivalent
     * newFixedThreadPool(1) the returned executor is
     * guaranteed not to be reconfigurable to use additional threads.
     *
     创建单工作线程与无界队列的执行器（如果工作线程在线程池关闭之前，执行任务的过程，
     工作线程由于失败结束，则一个新工作线程将会创建，替代旧的工作线程）。
     * @return the newly created single-threaded Executor
     */
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue()));
    }
    //FinalizableDelegatedExecutorService，所有操作委托给执行器代理
    static class FinalizableDelegatedExecutorService
        extends DelegatedExecutorService {
        FinalizableDelegatedExecutorService(ExecutorService executor) {
            super(executor);
        }
	//回收时关闭执行器
        protected void finalize() {
            super.shutdown();
        }
    }
    /**
    执行器静态代理，所有方法委托给内部执行器
     * A wrapper class that exposes only the ExecutorService methods
     * of an ExecutorService implementation.
     */
    static class DelegatedExecutorService extends AbstractExecutorService {
        private final ExecutorService e;
        DelegatedExecutorService(ExecutorService executor) { e = executor; }
        public void execute(Runnable command) { e.execute(command); }
        public void shutdown() { e.shutdown(); }
        public List shutdownNow() { return e.shutdownNow(); }
        public boolean isShutdown() { return e.isShutdown(); }
        public boolean isTerminated() { return e.isTerminated(); }
        public boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException {
            return e.awaitTermination(timeout, unit);
        }
        public Future submit(Runnable task) {
            return e.submit(task);
        }
        public  Future submit(Callable task) {
            return e.submit(task);
        }
        public  Future submit(Runnable task, T result) {
            return e.submit(task, result);
        }
        public  List> invokeAll(Collection> tasks)
            throws InterruptedException {
            return e.invokeAll(tasks);
        }
        public  List> invokeAll(Collection> tasks,
                                             long timeout, TimeUnit unit)
            throws InterruptedException {
            return e.invokeAll(tasks, timeout, unit);
        }
        public  T invokeAny(Collection> tasks)
            throws InterruptedException, ExecutionException {
            return e.invokeAny(tasks);
        }
        public  T invokeAny(Collection> tasks,
                               long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {
            return e.invokeAny(tasks, timeout, unit);
        }
    }
}

//创建单线程执行器,与前一个方法的不同为，添加了线程工厂参数ThreadFactory
 public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
     return new FinalizableDelegatedExecutorService
         (new ThreadPoolExecutor(1, 1,
                                 0L, TimeUnit.MILLISECONDS,
                                 new LinkedBlockingQueue(),
                                 threadFactory));
 }

从上面来看Executors创建固定线程池，实际为ThreadPoolExecutor，核心线程池数量和最大线程池数量相等并且固定，任务队列为LinkedBlockingQueue；创建单线程执行器，通过单线程执行器代理，实际为线程池执行器的ThreadPoolExecutor静态代理，核心线程池数量和最大线程池数量相等并且为1，任务队列为LinkedBlockingQueue。
再来看newCachedThreadPool

/**
  * Creates a thread pool that creates new threads as needed, but
  * will reuse previously constructed threads when they are
  * available.  These pools will typically improve the performance
  * of programs that execute many short-lived asynchronous tasks.
  * Calls to execute will reuse previously constructed
  * threads if available. If no existing thread is available, a new
  * thread will be created and added to the pool. Threads that have
  * not been used for sixty seconds are terminated and removed from
  * the cache. Thus, a pool that remains idle for long enough will
  * not consume any resources. Note that pools with similar
  * properties but different details (for example, timeout parameters)
  * may be created using {@link ThreadPoolExecutor} constructors.
  *
  创建一个线程池，可以根据需要创建工作线程，如果有空闲工作线程，并且可用，
  则重用工作线程。这个线程池可以显著地改善执行大量执行时间短的异步任务场景的性能。
  当调用execute方法时，将重用空闲的工作线程。如果没有工作线程可利用，则
  将创建新的工作线程，添加到线程池。如果工作线程在60之内，没有执行任务，那个将会
  从工作线程缓存中移除。这样工作线程空闲足够的时间等待任务，并不会消耗太多的资源。
  * @return the newly created thread pool
  */
 public static ExecutorService newCachedThreadPool() {
     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                   60L, TimeUnit.SECONDS,
                                   new SynchronousQueue());
 }
//带线程工厂ThreadFactory参数的newCachedThreadPool方法
 public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                   60L, TimeUnit.SECONDS,
                                   new SynchronousQueue(),
                                   threadFactory);
 }

从newCachedThreadPool方法来看，核心线程池为0，最大线程池为Integer.MAX_VALUE，
工作线程可空闲时间为60秒，任务队列为SynchronousQueue。newCachedThreadPool方法
创建的线程适合需要执行大量执行时间短的异步任务场景。
再来看调度执行器创建：

/**
     * Creates a single-threaded executor that can schedule commands
     * to run after a given delay, or to execute periodically.
     * (Note however that if this single
     * thread terminates due to a failure during execution prior to
     * shutdown, a new one will take its place if needed to execute
     * subsequent tasks.)  Tasks are guaranteed to execute
     * sequentially, and no more than one task will be active at any
     * given time. Unlike the otherwise equivalent
     * newScheduledThreadPool(1) the returned executor is
     * guaranteed not to be reconfigurable to use additional threads.
     创建一个单线程的执行器可以执行延时任务和间歇性的任务（如果工作线程在线程池关闭之前，执行任务的过程，
     工作线程由于失败结束，则一个新工作线程将会创建，替代旧的工作线程）。
     保证任务按顺序执行，在任何时候不会有两个任务同时执行。

     * @return the newly created scheduled executor
     */
    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        //返回调度执行器代理
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }

  /**
    调度执行器静态代理，所有的方法通过内部的调度执行器
     * A wrapper class that exposes only the ScheduledExecutorService
     * methods of a ScheduledExecutorService implementation.
     */
    static class DelegatedScheduledExecutorService
            extends DelegatedExecutorService
            implements ScheduledExecutorService {
        private final ScheduledExecutorService e;
        DelegatedScheduledExecutorService(ScheduledExecutorService executor) {
            super(executor);
            e = executor;
        }
        public ScheduledFuture schedule(Runnable command, long delay,  TimeUnit unit) {
            return e.schedule(command, delay, unit);
        }
        public  ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit) {
            return e.schedule(callable, delay, unit);
        }
        public ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay,  long period, TimeUnit unit) {
            return e.scheduleAtFixedRate(command, initialDelay, period, unit);
        }
        public ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay,  long delay, TimeUnit unit) {
            return e.scheduleWithFixedDelay(command, initialDelay, delay, unit);
        }
    }

  //此方与上一个方法的不同为，待线程工厂参数
     public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1, threadFactory));
    }

从上面来看单线程调度器实际为调度执行器静态代理，实际的调度执行器为ScheduledThreadPoolExecutor。
根据核心线程池数量和线程工厂，构造调度线程池：

/**
  * Creates a thread pool that can schedule commands to run after a
  * given delay, or to execute periodically.
  * @param corePoolSize the number of threads to keep in the pool,
  * even if they are idle.
  * @return a newly created scheduled thread pool
  * @throws IllegalArgumentException if {@code corePoolSize < 0}
  */
 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
     return new ScheduledThreadPoolExecutor(corePoolSize);
 }
  public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }
 //不可重新配置的线程池执行器
 public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
        if (executor == null)
            throw new NullPointerException();
        return new DelegatedExecutorService(executor);
    }
//不可重新配置的调度线程池执行器
  public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor) {
        if (executor == null)
            throw new NullPointerException();
        return new DelegatedScheduledExecutorService(executor);
    }  

不可重新配置的线程池执行器和调度线程池执行器，通过线程池执行器和调度线程池执行器的静态代理来实现。
默认的线程工厂：这个前面已说，这里仅贴出代码，保证完整性

public static ThreadFactory defaultThreadFactory() {
        return new DefaultThreadFactory();
    }
 /**
     * The default thread factory
     */
    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-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

其他方法：

//根据Runnable和结果类型result创建一个Callable
 public static  Callable callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter(task, result);
    }
 //根据Runnable创建一个无返回结果的Callable
 public static Callable