類圖

原始碼：

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;


public class Executors {

    //構造器私有化(只能通過類去直接呼叫靜態方法,而不允許建立類的例項物件)
    private Executors() {}

    //建立一個固定大小的執行緒池，以共享的無界佇列方式來執行這些執行緒
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
    }

    //建立一個固定大小的執行緒池，以共享的無界佇列方式來執行這些執行緒，在需要時使用提供的 ThreadFactory 建立新執行緒
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),threadFactory);
    }


    //建立一個單個執行緒的執行緒池，以無界佇列方式來執行該執行緒
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));
    }

    //建立一個單個執行緒的執行緒池，以無界佇列方式來執行該執行緒，並在需要時使用提供的 ThreadFactory 建立新執行緒。
    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),threadFactory));
    }

    //建立一個可按需自動擴容的執行緒池，但優先重用執行緒池中空閒可用的執行緒
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
    }

    //建立一個可按需自動擴容的執行緒池，但優先重用執行緒池中空閒可用的執行緒，並在需要時使用提供的 ThreadFactory 建立新執行緒
    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>(),threadFactory);
    }

    //建立一個單執行緒執行程式，它可安排在給定延遲後執行命令或者定期地執行
    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }

    //建立一個單執行緒執行程式，它可安排在給定延遲後執行命令或者定期地執行
    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1, threadFactory));
    }

    //建立一個在一定延遲時間後排程命令的執行緒池，或者週期性執行的執行緒池
    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 newWorkStealingPool() {
        return new ForkJoinPool(Runtime.getRuntime().availableProcessors(),ForkJoinPool.defaultForkJoinWorkerThreadFactory,null, true);
    }

    //根據給定的並行等級，建立一個擁有足夠的執行緒數目的工作竊取的執行緒池
    public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool(parallelism,ForkJoinPool.defaultForkJoinWorkerThreadFactory,null, true);
    }

    //返回一個將所有已定義的ExecutorService方法委託給指定執行程式的物件，但是使用強制轉換可能無法訪問其他方法
    public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
        if (executor == null)
            throw new NullPointerException();
        return new DelegatedExecutorService(executor);
    }

    //返回一個將所有已定義的ScheduledExecutorService方法委託給指定執行程式的物件，但是使用強制轉換可能無法訪問其他方法
    public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor) {
        if (executor == null)
            throw new NullPointerException();
        return new DelegatedScheduledExecutorService(executor);//ScheduledExecutorService繼承了ExecutorService
    }

    //返回用於建立新執行緒的預設執行緒工廠
    public static ThreadFactory defaultThreadFactory() {
        return new DefaultThreadFactory();
    }

    // 返回用於建立新執行緒的執行緒工廠，這些新執行緒與當前執行緒具有相同的許可權
    public static ThreadFactory privilegedThreadFactory() {
        return new PrivilegedThreadFactory();
    }

    //返回 Callable 物件，呼叫它時可執行給定的任務並返回 null
    public static Callable<Object> callable(Runnable task) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<Object>(task, null);
    }

    //返回 Callable 物件，呼叫它時可執行給定的任務並返回給定的結果
    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

    //返回 Callable 物件，呼叫它時可執行給定特權的操作並返回其結果。
    public static Callable<Object> callable(final PrivilegedAction<?> action) {
        if (action == null)
            throw new NullPointerException();
        return new Callable<Object>() {
                  public Object call() { return action.run(); }
               };
    }

    //返回 Callable 物件，呼叫它時可執行給定特權的異常操作並返回其結果
    public static Callable<Object> callable(final PrivilegedExceptionAction<?> action) {
        if (action == null)
            throw new NullPointerException();
        return new Callable<Object>() {
                  public Object call() throws Exception { return action.run(); }
               };
    }

    //返回 Callable 物件，呼叫它時可在當前的訪問控制上下文中執行給定的 callable 物件
    public static <T> Callable<T> privilegedCallable(Callable<T> callable) {
        if (callable == null)
            throw new NullPointerException();
        return new PrivilegedCallable<T>(callable);
    }

    //返回 Callable 物件，呼叫它時可在當前的訪問控制上下文中，使用當前上下文類載入器作為上下文類載入器來執行給定的 callable 物件
    public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable) {
        if (callable == null)
            throw new NullPointerException();
        return new PrivilegedCallableUsingCurrentClassLoader<T>(callable);
    }

    /***************內部類************/
    //實現了Callable介面（可執行給定的任務並返回給定的結果）
    static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;

        //構造器
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }

        //實現了Callable介面定義的call方法
        public T call() {
            task.run();//執行所定義的Runnable方法
            return result;//返回 T result
        }
    }

    //實現了Callable介面
    static final class PrivilegedCallable<T> implements Callable<T> {
        private final Callable<T> task;
        private final AccessControlContext acc;

        //構造器
        PrivilegedCallable(Callable<T> task) {
            this.task = task;
            this.acc = AccessController.getContext();
        }

        //實現了Callable介面定義的call方法
        public T call() throws Exception {
            try {
                return AccessController.doPrivileged(
                    new PrivilegedExceptionAction<T>() {
                        public T run() throws Exception {
                            return task.call();
                        }
                    }, acc);
            } catch (PrivilegedActionException e) {
                throw e.getException();
            }
        }
    }

    //實現了Callable介面
    static final class PrivilegedCallableUsingCurrentClassLoader<T> implements Callable<T> {
        private final Callable<T> task;
        private final AccessControlContext acc;
        private final ClassLoader ccl;

        //構造器
        PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);            
                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
            }
            this.task = task;
            this.acc = AccessController.getContext();
            this.ccl = Thread.currentThread().getContextClassLoader();
        }

        //實現了Callable介面定義的call方法
        public T call() throws Exception {
            try {
                return AccessController.doPrivileged(
                    new PrivilegedExceptionAction<T>() {
                        public T run() throws Exception {
                            Thread t = Thread.currentThread();
                            ClassLoader cl = t.getContextClassLoader();
                            if (ccl == cl) {
                                return task.call();
                            } else {
                                t.setContextClassLoader(ccl);
                                try {
                                    return task.call();
                                } finally {
                                    t.setContextClassLoader(cl);
                                }
                            }
                        }
                    }, acc);
            } catch (PrivilegedActionException e) {
                throw e.getException();
            }
        }
    }

    //實現ThreadFactory介面（建立預設執行緒工廠）
    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-";//執行緒名稱初始化
        }

        //實現ThreadFactory介面：建立新執行緒的方法
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);//建立一個新的執行緒加入到當前執行緒組(執行緒名稱加1)
            if (t.isDaemon())//判斷是否設定了後臺守護標誌
                t.setDaemon(false);//設為後臺執行緒
            if (t.getPriority() != Thread.NORM_PRIORITY)//將執行緒優先順序統統設定為5
                t.setPriority(Thread.NORM_PRIORITY);//不為5的統統改成5
            return t;//返回建立的執行緒物件
        }
    }

    //繼承DefaultThreadFactory，增加成員變數，重寫newThread方法
    static class PrivilegedThreadFactory extends DefaultThreadFactory {
        private final AccessControlContext acc;

        private final ClassLoader ccl;//類載入器

        PrivilegedThreadFactory() {
            super();
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
            }
            this.acc = AccessController.getContext();
            this.ccl = Thread.currentThread().getContextClassLoader();
        }

        //重寫newThread方法
        public Thread newThread(final Runnable r) {
            return super.newThread(new Runnable() {
                public void run() {
                    AccessController.doPrivileged(new PrivilegedAction<Void>() {
                        public Void run() {
                            Thread.currentThread().setContextClassLoader(ccl);
                            r.run();
                            return null;
                        }
                    }, acc);
                }
            });
        }
    }

    //繼承AbstractExecutorService抽象類
    static class DelegatedExecutorService extends AbstractExecutorService {
        private final ExecutorService e;

        //構造器
        DelegatedExecutorService(ExecutorService executor) { e = executor; }

        //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public void execute(Runnable command) { e.execute(command); }

        //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public void shutdown() { e.shutdown(); }

        //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public List<Runnable> shutdownNow() { return e.shutdownNow(); }

       //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public boolean isShutdown() { return e.isShutdown(); }

       //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public boolean isTerminated() { return e.isTerminated(); }

       //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException {
            return e.awaitTermination(timeout, unit);
        }

       //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public Future<?> submit(Runnable task) {
            return e.submit(task);
        }

       //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public <T> Future<T> submit(Callable<T> task) {
            return e.submit(task);
        }

       //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public <T> Future<T> submit(Runnable task, T result) {
            return e.submit(task, result);
        }

       //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
            throws InterruptedException {
            return e.invokeAll(tasks);
        }

       //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
            throws InterruptedException {
            return e.invokeAll(tasks, timeout, unit);
        }

       //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
            throws InterruptedException, ExecutionException {
            return e.invokeAny(tasks);
        }

       //具體實現依賴於傳入的ExecutorService的實現類中定義的方法
        public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException {
            return e.invokeAny(tasks, timeout, unit);
        }
    }

    //繼承DelegatedExecutorService類，重寫了finalize()回收方法
    static class FinalizableDelegatedExecutorService extends DelegatedExecutorService {
        //構造器
        FinalizableDelegatedExecutorService(ExecutorService executor) {
            super(executor);
        }

        //重寫finalize()回收方法
        protected void finalize() {
            super.shutdown();
        }
    }

    //在DelegatedExecutorService的基礎上，增加了對ScheduledExecutorService介面的實現
    static class DelegatedScheduledExecutorService extends DelegatedExecutorService implements ScheduledExecutorService {
        private final ScheduledExecutorService e;

        //構造器
        DelegatedScheduledExecutorService(ScheduledExecutorService executor) {
            super(executor);
            e = executor;
        }

        //具體實現依賴於ScheduledExecutorService介面的實現
        public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
            return e.schedule(command, delay, unit);
        }

        //具體實現依賴於ScheduledExecutorService介面的實現
        public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
            return e.schedule(callable, delay, unit);
        }

        //具體實現依賴於ScheduledExecutorService介面的實現
        public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
            return e.scheduleAtFixedRate(command, initialDelay, period, unit);
        }

        //具體實現依賴於ScheduledExecutorService介面的實現
        public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
            return e.scheduleWithFixedDelay(command, initialDelay, delay, unit);
        }
    }
}
 

實現原理：

    

    1.newFixedThreadPool、newCachedThreadPool方法，最終都呼叫了ThreadPoolExecutor的構造方法：

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                          TimeUnit unit, BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory, RejectedExecutionHandler handler)
 

• corePoolSize：核心池的大小
• maxmumPoolSize：池中允許的最大執行緒數
• keepAliveTime：表示執行緒沒有任務執行時最多保持多久時間會終止
• unit：引數keepAliveTime的時間單位，有7種取值，在TimeUnit類中有7種靜態屬性：

        TimeUnit.DAYS; //天
        TimeUnit.HOURS; //小時
        TimeUnit.MINUTES; //分鐘
        TimeUnit.SECONDS; //秒
        TimeUnit.MILLISECONDS; //毫秒
        TimeUnit.MICROSECONDS; //微妙
        TimeUnit.NANOSECONDS; //納秒

• workQueue：一個阻塞佇列，用來儲存等待執行的任務，這個引數的選擇也很重要，會對執行緒池的執行過程產生重大影響，一般來說，這裡的阻塞佇列有以下幾種選擇：

        ArrayBlockingQueue;
        LinkedBlockingQueue;
        SynchronousQueue;

• threadFactory：建立新執行緒的工廠。
• handler：（拒絕策略）當執行緒池的任務快取佇列已滿並且執行緒池中的執行緒數目達到maximumPoolSize，如果還有任務到來就會採取任務拒絕策略，通常有以下四種策略：

ThreadPoolExecutor.AbortPolicy:丟棄任務並丟擲RejectedExecutionException異常。
ThreadPoolExecutor.DiscardPolicy：也是丟棄任務，但是不丟擲異常。
ThreadPoolExecutor.DiscardOldestPolicy：丟棄佇列最前面的任務，然後重新嘗試執行任務（重複此過程）
ThreadPoolExecutor.CallerRunsPolicy：由呼叫執行緒處理該任務

    ThreadPoolExecutor繼承了AbstractExecutorService抽象類。

 

    2.newSingleThreadExecutor()直接呼叫了FinalizableDelegatedExecutorService的構造方法：

    FinalizableDelegatedExecutorService(ExecutorService executor) {
       super(executor);
    }

    FinalizableDelegatedExecutorService繼承了DelegatedExecutorService：

DelegatedExecutorService(ExecutorService executor) {
       e = executor;
    }

    DelegatedExecutorService繼承了AbstractExecutorService。

 

    3.newSingleThreadScheduledExecutor()呼叫了DelegatedScheduledExecutorService的構造方法：

    DelegatedScheduledExecutorService(ScheduledExecutorService executor) {
       super(executor);
       e = executor;
    }

    DelegatedScheduledExecutorService 繼承了 DelegatedExecutorService 實現了 ScheduledExecutorService介面。

 

    4.newScheduledThreadPool()呼叫了ScheduledThreadPoolExecutor的構造方法：

    public ScheduledThreadPoolExecutor(int corePoolSize,ThreadFactory threadFactory, RejectedExecutionHandler handler) {
       super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue(), threadFactory, handler);
    }

    ScheduledThreadPoolExecutor 繼承了 ThreadPoolExecutor 實現了 ScheduledExecutorService 介面

    因此，最終呼叫的還是ThreadPoolExecutor的構造方法。

 

    5.newWorkStealingPool()最終呼叫了ForkJoinPool類的私有構造方法：

private ForkJoinPool(int parallelism,
                     ForkJoinWorkerThreadFactory factory,
                     UncaughtExceptionHandler handler,
                     int mode,
                     String workerNamePrefix) {
    this.workerNamePrefix = workerNamePrefix;
    this.factory = factory;
    this.ueh = handler;
    this.config = (parallelism & SMASK) | mode;
    long np = (long)(-parallelism); // offset ctl counts
    this.ctl = ((np << AC_SHIFT) & AC_MASK) | ((np << TC_SHIFT) & TC_MASK);
}

        此處不做具體分析，ForkJoinPool繼承了AbstractExecutorService抽象類。

    綜合分析，可以發現Executors類，主要提供了建立ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 類的工廠和實用方法。

 

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads)

    建立一個可重用固定執行緒數的執行緒池，以共享的無界佇列方式來執行這些執行緒。在任意點，在大多數 nThreads 執行緒會處於處理任務的活動狀態。如果在所有執行緒處於活動狀態時提交附加任務，則在有可用執行緒之前，附加任務將在佇列中等待。如果在關閉前的執行期間由於失敗而導致任何執行緒終止，那麼一個新執行緒將代替它執行後續的任務（如果需要）。在某個執行緒被顯式地 關閉之前，池中的執行緒將一直存在。

    引數：

    nThreads - 池中的執行緒數

    返回：

        新建立的執行緒池

    丟擲：

    IllegalArgumentException - 如果 nThreads <= 0

 

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads,
                                                 ThreadFactory threadFactory)

    建立一個可重用固定執行緒數的執行緒池，以共享的無界佇列方式來執行這些執行緒，在需要時使用提供的 ThreadFactory 建立新執行緒。在任意點，在大多數 nThreads 執行緒會處於處理任務的活動狀態。如果在所有執行緒處於活動狀態時提交附加任務，則在有可用執行緒之前，附加任務將在佇列中等待。如果在關閉前的執行期間由於失敗而導致任何執行緒終止，那麼一個新執行緒將代替它執行後續的任務（如果需要）。在某個執行緒被顯式地 關閉之前，池中的執行緒將一直存在。

    引數：

    nThreads - 池中的執行緒數

    threadFactory - 建立新執行緒時使用的工廠

    返回：

        新建立的執行緒池

    丟擲：

    NullPointerException - 如果 threadFactory 為 null

    IllegalArgumentException - 如果 nThreads <= 0

 

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor()

    建立一個使用單個 worker 執行緒的 Executor，以無界佇列方式來執行該執行緒。（注意，如果因為在關閉前的執行期間出現失敗而終止了此單個執行緒，那麼如果需要，一個新執行緒將代替它執行後續的任務）。可保證順序地執行各個任務，並且在任意給定的時間不會有多個執行緒是活動的。與其他等效的 newFixedThreadPool(1) 不同，可保證無需重新配置此方法所返回的執行程式即可使用其他的執行緒。

    返回：

        新建立的單執行緒 Executor

 

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)

    建立一個使用單個 worker 執行緒的 Executor，以無界佇列方式來執行該執行緒，並在需要時使用提供的 ThreadFactory 建立新執行緒。與其他等效的 newFixedThreadPool(1, threadFactory) 不同，可保證無需重新配置此方法所返回的執行程式即可使用其他的執行緒。

    引數：

    threadFactory - 建立新執行緒時使用的工廠

    返回：

        新建立的單執行緒 Executor

    丟擲：

    NullPointerException - 如果 threadFactory 為 null

 

newCachedThreadPool

public static ExecutorService newCachedThreadPool()

    建立一個可根據需要建立新執行緒的執行緒池，但是在以前構造的執行緒可用時將重用它們。對於執行很多短期非同步任務的程式而言，這些執行緒池通常可提高程式效能。呼叫 execute 將重用以前構造的執行緒（如果執行緒可用）。如果現有執行緒沒有可用的，則建立一個新執行緒並新增到池中。終止並從快取中移除那些已有 60 秒鐘未被使用的執行緒。因此，長時間保持空閒的執行緒池不會使用任何資源。注意，可以使用ThreadPoolExecutor 構造方法建立具有類似屬性但細節不同（例如超時引數）的執行緒池。

    返回：

        新建立的執行緒池

 

newCachedThreadPool

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)

    建立一個可根據需要建立新執行緒的執行緒池，但是在以前構造的執行緒可用時將重用它們，並在需要時使用提供的 ThreadFactory 建立新執行緒。

    引數：

    threadFactory - 建立新執行緒時使用的工廠

    返回：

        新建立的執行緒池

    丟擲：

    NullPointerException - 如果 threadFactory 為 null

 

newSingleThreadScheduledExecutor

public static ScheduledExecutorService newSingleThreadScheduledExecutor()

    建立一個單執行緒執行程式，它可安排在給定延遲後執行命令或者定期地執行。（注意，如果因為在關閉前的執行期間出現失敗而終止了此單個執行緒，那麼如果需要，一個新執行緒會代替它執行後續的任務）。可保證順序地執行各個任務，並且在任意給定的時間不會有多個執行緒是活動的。與其他等效的 newScheduledThreadPool(1) 不同，可保證無需重新配置此方法所返回的執行程式即可使用其他的執行緒。

    返回：

        新建立的安排執行程式

 

newSingleThreadScheduledExecutor

public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)

    建立一個單執行緒執行程式，它可安排在給定延遲後執行命令或者定期地執行。（注意，如果因為在關閉前的執行期間出現失敗而終止了此單個執行緒，那麼如果需要，一個新執行緒會代替它執行後續的任務）。可保證順序地執行各個任務，並且在任意給定的時間不會有多個執行緒是活動的。與其他等效的 newScheduledThreadPool(1, threadFactory) 不同，可保證無需重新配置此方法所返回的執行程式即可使用其他的執行緒。

    引數：

    threadFactory - 建立新執行緒時使用的工廠

    返回：

        新建立的安排執行程式

    丟擲：

    NullPointerException - 如果 threadFactory 為 null

 

newScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

    建立一個執行緒池，它可安排在給定延遲後執行命令或者定期地執行。

    引數：

    corePoolSize - 池中所儲存的執行緒數，即使執行緒是空閒的也包括在內。

    返回：

        新建立的安排執行緒池

    丟擲：

    NullPointerException - 如果 threadFactory 為 null

 

newScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

    建立一個執行緒池，它可安排在給定延遲後執行命令或者定期地執行。

    引數：

    corePoolSize - 池中所儲存的執行緒數，即使執行緒是空閒的也包括在內

    threadFactory - 執行程式建立新執行緒時使用的工廠

    返回：

        新建立的安排執行緒池

    丟擲：

    IllegalArgumentException - 如果 corePoolSize < 0

    NullPointerException - 如果 threadFactory 為 null

 

unconfigurableExecutorService

public static ExecutorService unconfigurableExecutorService(ExecutorService executor)

    返回一個將所有已定義的 ExecutorService 方法委託給指定執行程式的物件，但是使用強制轉換可能無法訪問其他方法。這提供了一種可安全地“凍結”配置並且不允許調整給定具體實現的方法。

    引數：

    executor - 底層實現

    返回：

        一個 ExecutorService 例項

    丟擲：

    NullPointerException - 如果 executor 為 null

 

unconfigurableScheduledExecutorService

public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor)

    返回一個將所有已定義的 ExecutorService 方法委託給指定執行程式的物件，但是使用強制轉換可能無法訪問其他方法。這提供了一種可安全地“凍結”配置並且不允許調整給定具體實現的方法。

    引數：

    executor - 底層實現

    返回：

        一個 ScheduledExecutorService 例項

    丟擲：

    NullPointerException - 如果 executor 為 null

 

defaultThreadFactory

public static ThreadFactory defaultThreadFactory()

    返回用於建立新執行緒的預設執行緒工廠。此工廠建立同一 ThreadGroup 中 Executor 使用的所有新執行緒。如果有 SecurityManager，則它使用 System.getSecurityManager() 組來呼叫此 defaultThreadFactory 方法，其他情況則使用執行緒組。每個新執行緒都作為非守護程式而建立，並且具有設定為 Thread.NORM_PRIORITY 中較小者的優先順序以及執行緒組中允許的最大優先順序。新執行緒具有可通過 pool-N-thread-M 的 Thread.getName() 來訪問的名稱，其中 N 是此工廠的序列號， M 是此工廠所建立執行緒的序列號。

    返回：

        執行緒工廠

 

privilegedThreadFactory

public static ThreadFactory privilegedThreadFactory()

    返回用於建立新執行緒的執行緒工廠，這些新執行緒與當前執行緒具有相同的許可權。此工廠建立具有與 defaultThreadFactory() 相同設定的執行緒，新執行緒的 AccessControlContext 和 contextClassLoader 的其他設定與呼叫此 privilegedThreadFactory 方法的執行緒相同。可以在 AccessController.doPrivileged(java.security.PrivilegedAction ) 操作中建立一個新 privilegedThreadFactory，設定當前執行緒的訪問控制上下文，以便建立具有該操作中保持的所選許可權的執行緒。

    注意，雖然執行在此類執行緒中的任務具有與當前執行緒相同的訪問控制和類載入器，但是它們無需具有相同的 ThreadLocal 或 InheritableThreadLocal 值。如有必要，使用 ThreadPoolExecutor.beforeExecute(java.lang.Thread, java.lang.Runnable) 在 ThreadPoolExecutor 子類中執行任何任務前，可以設定或重置執行緒區域性變數的特定值。另外，如果必須初始化 worker 執行緒，以具有與某些其他指定執行緒相同的 InheritableThreadLocal 設定，則可以線上程等待和服務建立請求的環境中建立自定義的 ThreadFactory，而不是繼承其值。

    返回：

        執行緒工廠

    丟擲：

    AccessControlException - 如果當前訪問控制上下文沒有獲取和設定上下文類載入器的許可權。

 

callable

public static <T> Callable<T> callable(Runnable task,T result)

    返回 Callable 物件，呼叫它時可執行給定的任務並返回給定的結果。這在把需要 Callable 的方法應用到其他無結果的操作時很有用。

    引數：

    task - 要執行的任務

    result - 返回的結果

    返回：

        一個 callable 物件

    丟擲：

    NullPointerException - 如果 task 為 null

 

callable

public static Callable<Object> callable(Runnable task)

    返回 Callable 物件，呼叫它時可執行給定的任務並返回 null。

    引數：

    task - 要執行的任務

    返回：

        一個 callable 物件

    丟擲：

    NullPointerException - 如果 task 為 null

 

callable

public static Callable<Object> callable(PrivilegedAction<?> action)

    返回 Callable 物件，呼叫它時可執行給定特權的操作並返回其結果。

    引數：

    action - 要執行的特權操作

    返回：

        一個 callable 物件

    丟擲：

    NullPointerException - 如果 action 為 null

 

callable

public static Callable<Object> callable(PrivilegedExceptionAction<?> action)

    返回 Callable 物件，呼叫它時可執行給定特權的異常操作並返回其結果。

    引數：

    action - 要執行的特權異常操作

    返回：

        一個 callable 物件

    丟擲：

    NullPointerException - 如果 action 為 null

 

privilegedCallable

public static <T> Callable<T> privilegedCallable(Callable<T> callable)

    返回 Callable 物件，呼叫它時可在當前的訪問控制上下文中執行給定的 callable 物件。通常應該在 AccessController.doPrivileged(java.security.PrivilegedAction ) 操作中呼叫此方法，以便建立 callable 物件，並且如有可能，則在該操作中保持的所選許可權設定下執行此物件；如果無法呼叫，則丟擲相關的 AccessControlException。

    引數：

    callable - 底層任務

    返回：

        一個 callable 物件

    丟擲：

    NullPointerException - 如果 callable 為 null

 

privilegedCallableUsingCurrentClassLoader

public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable)

    返回 Callable 物件，呼叫它時可在當前的訪問控制上下文中，使用當前上下文類載入器作為上下文類載入器來執行給定的 callable 物件。通常應該在 AccessController.doPrivileged(java.security.PrivilegedAction )操作中呼叫此方法，以建立 callable 物件，並且如有可能，則在該操作中保持的所選許可權設定下執行此物件；如果無法呼叫，則丟擲相關的 AccessControlException。

    引數：

    callable - 底層任務

    返回：

        一個 callable 物件

    丟擲：

    NullPointerException - 如果 callable 為 null

    AccessControlException - 如果當前的訪問控制上下文沒有設定和獲得上下文類載入器的許可權。

 

 

常用的4種執行緒池的使用：

    通過Executors提供四種執行緒池：newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor、newScheduledThreadPool。

1.public static ExecutorService newFixedThreadPool(int nThreads) 
建立固定數目執行緒的執行緒池。

2.public static ExecutorService newCachedThreadPool() 
建立一個可快取的執行緒池，呼叫execute將重用以前構造的執行緒（如果執行緒可用）。如果現有執行緒沒有可用的，則建立一個新執行緒並新增到池中。終止並從快取中移除那些已有 60 秒鐘未被使用的執行緒。

3.public static ExecutorService newSingleThreadExecutor() 
建立一個單執行緒化的Executor。

4.public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 
建立一個支援定時及週期性的任務執行的執行緒池，多數情況下可用來替代Timer類。

    newFixedThreadPool建立一個指定工作執行緒數量的執行緒池。每當提交一個任務就建立一個工作執行緒，如果工作執行緒數量達到執行緒池初始的最大數，提交的任務則進入佇列等待，等著有閒置的執行緒來執行這些任務。它具有執行緒池提高程式效率和節省建立執行緒時所耗的開銷的優點。但是，線上程池空閒時，即執行緒池中沒有可執行任務時，它不會釋放工作執行緒，還會佔用一定的系統資源。

        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 20; i++) {
            Runnable syncRunnable = new Runnable() {
                public void run() {
                   //...
                }
            };
            executorService.execute(syncRunnable);
        }

    newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。

• 工作執行緒的建立數量幾乎沒有限制(其實也有限制的,數目為Interger. MAX_VALUE), 這樣可靈活的往執行緒池中新增執行緒。
• 在建立任務時，若有空閒的執行緒時則複用空閒的執行緒，若沒有則新建執行緒。
• 如果存在某一執行緒持續一段時間沒有工作(預設為1分鐘)，則該執行緒就會銷燬回收。

        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            Runnable syncRunnable = new Runnable() {
                public void run() {
                    //...
                }
            };
            executorService.execute(syncRunnable);
        }

    newSingleThreadExecutor建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。特點:有且僅有一個工作執行緒執行任務，所有任務按照指定順序執行，即遵循佇列的入隊出隊規則。

        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 20; i++) {
            Runnable syncRunnable = new Runnable() {
                @Override
                public void run() {
                   //...
                }