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

    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    private static final int COUNT_BITS = Integer.SIZE - 3;       // = 29
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }

	public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

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

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    } 

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

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

public class MyThreadFactory implements ThreadFactory {
    public final String poolName;
    
    public MyThreadFactory(String poolName) {
        this.poolName = poolName;
    }
    
    public Threaed newThread(Runnable runnable) {
        return new MyAppThread(runnable, poolName);
    }
}

public class MyAppThread extends Thread {  
    private static final AtomicInteger created = new AtomicInteger();
    private static volatile boolean debugLifecycle = false;
    private static final AtomicInteger alive = new AtomicInteger();  // 存活线程数
    
    public MyAppThread(Runnable runnable, String name) {
        super(runnable, name + "-" + created.incrementAndGet());
        setUncaughtExceptionHandler(    // 定制 UncaughtExceptionHandler
        	new Thread.UncaughtExceptionHandler() {
                public void uncaughtException(Thread t, Throwable e) {
                    log.log(Level.SERVER, "UNCAUGHT in thread " + t.getName(), e);
                }
            });
    }
    
    public void run() {
        boolean debug = debugLifecycle;
        if (debug) { log.log(Level.FINE, "Created " + getName()); }
        try {
            alive.incrementAndGet();
            super.run();
        } finally {
            alive.decrementAndGet();
            if (debug) { log.log(Level.FINE, "Exiting " + getName()); }
        }
    }
    
    public static int getThreadAlive() { return alive.get(); }
}

ExecutorService exec = Executors.newCachedThreadPool();
if (exec instanceof ThreadPoolExecutor) {
    ((ThreadPoolExecutor) exec).setCorePoolSize(10);
} else {
    throw new AssertionError("Oops, bad assuption");
}

// 串行循环
void processSequentially(List<Element> elements) {
 for (Element e : elements) {
  process(e);
 }
}

// 并行循环
void processInParallel(Executor exec, List<Element> elements) {
 for (final Element e : elements) {
  exec.execute(new Runnable() {
   public void run() { process(e); }
  });
 }
}

// JDK 1.8
public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
    	 // 任务为空，抛异常
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            // 当前有核心线程空闲，调用核心线程执行任务
            if (addWorker(command, true))
                return;
            c = ctl.get();
            // 若 addWorker 调用核心线程失败，则更新 ctl，执行下方代码，将任务添加进队列
        }
    
        if (isRunning(c) && workQueue.offer(command)) {
            // 当前核心线程无空闲，则将任务添加到任务队列中
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            // 再次检查线程池状态，不在 RUNNING 状态则从队列中移除任务，执行拒绝策略
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
            // 若线程池处于 RUNNING 状态，但没有 worker，则创建线程
        }
    
        else if (!addWorker(command, false))
            reject(command);
   	// 如果任务队列满了无法加入，则会创建非核心线程执行任务，若失败则执行拒绝策略
    }

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
            // 

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                // 根据 core 的布尔值创建核心 / 非核心线程，若当前线程数以达到预设值，则返回 false
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                // 满足可以新增线程的条件，CAS 更新 ctl，跳出循环
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
                // CAS 更新失败，若线程池状态没变，重复当前 for 循环，状态变了则从 retry 重来
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);               // 这里会创建一个新的线程
            final Thread t = w.thread;
            if (t != null) {             // 若线程创建失败，则跳至最下方 finally
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        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);
            // 创建线程失败，则执行 addWorkerFailed(w)
        }
        return workerStarted;         // 返回是否成功创建线程并开始任务
    }

    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable      // 实现了 Runnable 接口
    {
        final Thread thread;
        Runnable firstTask;
        volatile long completedTasks;
        
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);  // 调用构造器时，会新开一个线程
        }

        public void run() {       // 线程开始工作时调用这个 run 
            runWorker(this);
        }

	final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
            // 执行自己的任务或者从任务队列中取出一个任务
                w.lock();
                // 将 Worker 自身上锁
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                // 检测线程池状态，若线程池处于中断状态，当前线程将中断
                try {
                    beforeExecute(wt, task);       // 执行 beforeExecute
                    Throwable thrown = null;
                    try {
                        task.run();       // 执行任务
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);      // 执行 afterExecute
                    }
                } finally { n
                    task = null;
                    w.completedTasks++;
                    w.unlock();   // 解锁 Worker
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }
        

    private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            // allowCoreThreadTimeOut 变量默认是 false，核⼼线程即使空闲也不会被销毁
            // 如果为 true，核⼼线程在 keepAliveTime 内仍空闲则会被销毁。

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
            // 如果运⾏线程数超过了最⼤线程数，但是缓存队列已经空了，这时递减 worker 数量。
            // 如果有设置允许线程超时或者线程数量超过了核⼼线程数量，
            // 并且线程在规定时间内均未 poll 到任务，且队列为空则递减 worker 数量
                continue;
            }

            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }