public class ThreadPoolTest {

    static class MyThread implements Runnable {

        private String name;

        public MyThread(String name) {

            this.name = name;

        }

        @Override

        public void run() {

            try {

                Thread.sleep(1000);

                System.out.println(name + " finished job!") ;

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

    public static void main(String[] args) {

        // 创建线程池，为了更好的明白运行流程，增加了一些额外的代码

//        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(2);

        BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();

//        BlockingQueue<Runnable> queue = new PriorityBlockingQueue<Runnable>();

//        BlockingQueue<Runnable> queue = new SynchronousQueue<Runnable>();

        // AbortPolicy/CallerRunsPolicy/DiscardOldestPolicy/DiscardPolicy

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 5, TimeUnit.SECONDS,

                queue, new ThreadPoolExecutor.AbortPolicy());

        for (int i = 0; i < 10; i++) {

            System.out.println("当前线程池大小[" + threadPool.getPoolSize() + "],当前队列大小[" + queue.size() + "]");

            threadPool.execute(new MyThread("Thread" + i));

        }

        // 关闭线程池

        threadPool.shutdown();

    }

}

public ThreadPoolExecutor(int corePoolSize,    //核心线程的数量

                          int maximumPoolSize,    //最大线程数量

                          long keepAliveTime,    //超出核心线程数量以外的线程空余存活时间

                          TimeUnit unit,    //存活时间的单位

                          BlockingQueue<Runnable> workQueue,    //保存待执行任务的队列

                          ThreadFactory threadFactory,    //创建新线程使用的工厂

                          RejectedExecutionHandler handler // 当任务无法执行时的处理器

                          ) {...}

public void execute(Runnable command) {

    if (command == null)

        throw new NullPointerException();

    int c = ctl.get();

    //1.当前池中线程比核心数少，新建一个线程执行任务

    if (workerCountOf(c) < corePoolSize) {

        if (addWorker(command, true))

            return;

        c = ctl.get();

    }

    //2.核心池已满，但任务队列未满，添加到队列中，所以：如果是*队列，添加的任务超过核心线程后，不会创建非核心线程，maximumPoolSize参数无效

    if (isRunning(c) && workQueue.offer(command)) {

        int recheck = ctl.get();

        if (! isRunning(recheck) && remove(command))    //如果这时被关闭了，拒绝任务

            reject(command);

        else if (workerCountOf(recheck) == 0)    //如果之前的线程已被销毁完，新建一个线程

            addWorker(null, false);

    }

    //3.核心池已满，队列已满，试着创建一个新线程

    else if (!addWorker(command, false))

        reject(command);    //如果创建新线程失败了，说明线程池被关闭或者线程池完全满了，拒绝任务

}

    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 ExecutorService newCachedThreadPool() {

        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                      60L, TimeUnit.SECONDS,

                                      new SynchronousQueue<Runnable>());

    }

    /**

     * Class Worker mainly maintains interrupt control state for

     * threads running tasks, along with other minor bookkeeping.

     * This class opportunistically extends AbstractQueuedSynchronizer

     * to simplify acquiring and releasing a lock surrounding each

     * task execution.  This protects against interrupts that are

     * intended to wake up a worker thread waiting for a task from

     * instead interrupting a task being run.  We implement a simple

     * non-reentrant mutual exclusion lock rather than use

     * ReentrantLock because we do not want worker tasks to be able to

     * reacquire the lock when they invoke pool control methods like

     * setCorePoolSize.  Additionally, to suppress interrupts until

     * the thread actually starts running tasks, we initialize lock

     * state to a negative value, and clear it upon start (in

     * runWorker).

     */

    private final class Worker

        extends AbstractQueuedSynchronizer

        implements Runnable