demo代码：

    1. public class ThreadPoolExecutorSample {
    3.     public static void main(String[] args) throws IOException, InterruptedException {
    4.         //阻塞队列,大小设置为2,方便查看运行过程
    5.         int blockQueueSize = 2;
    6.         BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(blockQueueSize);
    8.         //线程工厂,可以为线程池启动的线程做一些自定义的处理,比如做标识方便区分查看结果
    9.         ThreadFactory threadFactory = new MyTreadFactory();
    11.         //拒绝策略,比如拒绝执行了可以在里面自定义一些返回内容
    12.         RejectedExecutionHandler handler = new MyIgnoreHandle();
    14.         //核心线程数为2,最大线程数为3,空闲时间为10,设置小点是为了方便打印查看执行过程
    15.         int corePoolSize = 2;
    16.         int maximumPoolSize = 3;
    17.         ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 2000, TimeUnit.SECONDS, workQueue, threadFactory, handler);
    19.         //这里是预启动所有的核心线程,不加这句话如果没有任务的情况下线程池里是没有线程的
    20.         //executor.prestartAllCoreThreads();
    21.         for (int i = 1; i <= 10; i++) {
    22.             MyTask task = new MyTask(String.valueOf(i));
    23.             executor.execute(task);
    24.             Thread.sleep(10);
    25.         }
    26.     }
    28.     static class MyTreadFactory implements ThreadFactory {
    29.         private final AtomicInteger mThreadNum = new AtomicInteger(1);
    30.         @Override
    31.         public Thread newThread(Runnable r) {
    32.             String name = "";
    33.             if(mThreadNum.get()<=2){
    34.                 name = "my-thread-" + mThreadNum.get() + "-核心线程";
    35.             }
    36.             else{
    37.                 name = "my-thread-" + mThreadNum.get() + "-非核心线程";
    38.             }
    39.             Thread t = new Thread(r, name);
    40.             System.out.println(t.getName() + " has been created");
    41.             mThreadNum.getAndIncrement();
    42.             return t;
    43.         }
    44.     }
    46.     static class MyIgnoreHandle implements RejectedExecutionHandler {
    47.         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    48.             //这里是可以重写拒绝队列的,比如一些不允许拒绝的任务我们可以写到redis缓存里，再专门开一个线程来重新执行拒绝的任务
    49.             //这里就简单做日志输出记录了
    50.             doLog(r, e);
    51.         }
    52.         private void doLog(Runnable r, ThreadPoolExecutor e) {
    53.             System.err.println( r.toString() + " rejected");
    54.         }
    55.     }
    57.     static class MyTask implements Runnable {
    58.         private String name;
    59.         public MyTask(String name) {
    60.             this.name = name;
    61.         }
    62.         @Override
    63.         public void run() {
    64.             try {
    65.                 System.out.println(this.toString() + " is running!");
    66.                 //让任务执行慢点
    67.                 Thread.sleep(6000);
    68.             } catch (InterruptedException e) {
    69.                 e.printStackTrace();
    70.             }
    71.         }
    72.         public String getName() {
    73.             return name;
    74.         }
    75.         @Override
    76.         public String toString() {
    77.             return "MyTask [name=" + name + "]";
    78.         }
    79.     }
    80. }

    demo参数设置：
    阻塞队列数：2
    核心线程数为：2
    最大线程数为：3，那非核心线程数只有1个
    执行结果：
    image.png
    demo执行结果分析：
    在1-10的for循环体里：
    1.任务1进来，此时线程池还没有线程，线程池此时会创建第1个核心线程来执行任务。
    2.任务2进来，此时线程池只有1个核心线程，线程池此时会创建第2个核心线程来执行任务2。
    3.任务3进来，此时线程池已经有2个核心线程，达到预设的核心线程数，任务3只能去阻塞队列排队了。
    4.任务4进来，此时线程池已经有2个核心线程，达到预设的核心线程数，任务4只能去阻塞队列排队了。
    5.任务5进来，此时线程池已经有2个核心线程，达到预设的核心线程数，任务5只能去阻塞队列排队了，但发现此时的阻塞队列也达到预设的阻塞队列数，此时线程池会去创建非核心线程3出来执行任务5。
    6.任务6进来，此时线程池里有2个核心线程和1个非核心线程，3个线程数已经达到预设的最大线程数了，并且3个线程都已经有未执行完成的任务，分别是任务1、任务2和任务5，并且阻塞队列也已经排满了任务，分别是任务3和任务4，那么任务6就只有被拒绝了，拒绝策略里的日志打印也便执行了。
    7.后面的任务7、8、9、10都是一样的，线程池满了，阻塞队列也满了，只有被拒绝了。