/**

     * 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

     * <tt>newFixedThreadPool(1)</tt> 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<Runnable>()));

    }

    /**

     * Creates a new {@code ThreadPoolExecutor} with the given initial

     * parameters and default thread factory and rejected execution handler.

     * It may be more convenient to use one of the {@link Executors} factory

     * methods instead of this general purpose constructor.

     *

     * @param corePoolSize the number of threads to keep in the pool, even

     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set

     * @param maximumPoolSize the maximum number of threads to allow in the

     *        pool

     * @param keepAliveTime when the number of threads is greater than

     *        the core, this is the maximum time that excess idle threads

     *        will wait for new tasks before terminating.

     * @param unit the time unit for the {@code keepAliveTime} argument

     * @param workQueue the queue to use for holding tasks before they are

     *        executed.  This queue will hold only the {@code Runnable}

     *        tasks submitted by the {@code execute} method.

     * @throws IllegalArgumentException if one of the following holds:<br>

     *         {@code corePoolSize < 0}<br>

     *         {@code keepAliveTime < 0}<br>

     *         {@code maximumPoolSize <= 0}<br>

     *         {@code maximumPoolSize < corePoolSize}

     * @throws NullPointerException if {@code workQueue} is null

     */

    public ThreadPoolExecutor(int corePoolSize,

                              int maximumPoolSize,

                              long keepAliveTime,

                              TimeUnit unit,

                              BlockingQueue<Runnable> workQueue) {

        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,

             Executors.defaultThreadFactory(), defaultHandler);

    }

package com.hqs.core;

import java.util.concurrent.RejectedExecutionHandler;

import java.util.concurrent.ThreadPoolExecutor;

public class RejectedFullHandler implements RejectedExecutionHandler {

    @Override

    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

        System.out.println(r.toString() + " I am rejected!");

    }

}

package com.hqs.core;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorTest implements Runnable {

    private int i;

    private CountDownLatch cdl;

    public ThreadPoolExecutorTest(int i, CountDownLatch cdl) {

        this.i = i;

        this.cdl = cdl;

    }

    public void run() {

        try {

            TimeUnit.SECONDS.sleep(3);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println(i + " is running");

        cdl.countDown();

    }

    @Override

    public String toString() {

        return "i:" + i;

    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        BlockingQueue queue = new ArrayBlockingQueue<>(2); //定义一个阻塞队列，长度为2

        CountDownLatch cdl = new CountDownLatch(5); //设置一个减门闩，用于递减动作

　　　　　//定义了2个核心线程，3个最大线程，空闲线程持续5秒钟，阻塞队列，拒绝处理执行类
　　　　  ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 3, 5, TimeUnit.SECONDS, queue, new RejectedFullHandler()); 

　　　　　

        //threadPool.allowCoreThreadTimeOut(true); //设置是否将空闲的核心线程超时后停止

        for(int i = 1; i <= 6; i++ ) {

            ThreadPoolExecutorTest t1 = new ThreadPoolExecutorTest(i, cdl);

            threadPool.execute(t1);

//            FutureTask future = (FutureTask)threadPool.submit(t1); //此处注释，因为submit传的参数是Runnable而不是Callable，所以返回结果为null

            System.out.println("queue content:" + queue.toString()); //将queue的内容打印出来

        }

        try {

            cdl.await(); //所有线程执行完之后，主线程继续往下进行。

        } catch (InterruptedException e1) {

            e1.printStackTrace();

        }

        try {

            TimeUnit.SECONDS.sleep(6);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println("poosize :" + threadPool.getPoolSize()); //输出PoolSize

        threadPool.shutdown();  //注意，所以线程池的最后都必须要显示的关闭

    }

}

queue content:[]

queue content:[]

queue content:[i:3]

queue content:[i:3, i:4]

queue content:[i:3, i:4]

i:6 I am rejected!

queue content:[i:3, i:4]

1 is running

2 is running

5 is running

3 is running

4 is running

poosize :2