ThreadPoolExecutor类简介

在java线程池中的newCachedThreadPool，newFixedThreadPool，newSingleThreadExecutor，newScheduledThreadPool这四个线程池在底层都是调用了ThreadPoolExecutor()这个构造方法。

若Executors这个类无法满足我们的需求的时候，可以自己创建自定义的线程池，ThreadPoolExecutor类的定义如下

public ThreadPoolExecutor(int corePoolSize,//核心线程数--线程池初始化创建的线程数量
            int maximumPoolSize,//最大线程数，线程池中能创建的最大线程数
            long keepAliveTime,//线程存活时间
            TimeUnit unit,//线程存货时间单位
            BlockingQueue<Runnable> workQueue,//一个阻塞队列
            ThreadFactory threadFactory//拒绝策略
            ) {……}

那么在使用这个方法自定义线程池的时候我们要注意些什么呢？

这个ThreadPoolExecutor()构造方法，对于队列是什么类型的比较关键，

1.在使用有界队列的时候：

若有新的任务需要执行，如果线程池实际线程数小于corePoolSize核心线程数的时候，则优先创建线程。若大于corePoolSize时，则会将多余的线程存放在队列中，若队列已满，且最请求线程小于maximumPoolSize的情况下，则自定义的线程池会创建新的线程，若队列已满，且最请求线程大于maximumPoolSize的情况下，则执行拒绝策略，或其他自定义方式。

一个小的Demo说明上面的情况

public class MyTask implements Runnable{
private int id;
private String name;
public int getId() {
    return id;
}
public void setId(int id) {
    this.id = id;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public MyTask(int id, String name) {
    super();
    this.id = id;
    this.name = name;
}
@Override
public void run() {
    try {
        System.out.println("run taskId = "+this.id);
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
@Override
    public String toString() {
        return Integer.toString(this.id);
    }
}

上面创建了一个类实现了Runable()接口

public class MyThreadPool {
    public static void main(String[] args) {
        /**
         * 1.在使用有界队列的时候：若有新的任务需要执行，如果线程池实际线程数小于corePoolSize核心线程数的时候，则优先创建线程。
         * 若大于corePoolSize时，则会将多余的线程存放在队列中，
         * 若队列已满，且最请求线程小于maximumPoolSize的情况下，则自定义的线程池会创建新的线程，
         * 若队列已满，且最请求线程大于maximumPoolSize的情况下，则执行拒绝策略，或其他自定义方式。
         */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(// 自定义一个线程池
                1, // coreSize
                2, // maxSize
                60, // 60s
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(3) // 有界队列，容量是3个
        );
        MyTask task1 = new MyTask(1, "task1");
        MyTask task2 = new MyTask(2, "task2");
        MyTask task3 = new MyTask(3, "task3");
        MyTask task4 = new MyTask(4, "task4");
        MyTask task5 = new MyTask(5, "task5");
        MyTask task6 = new MyTask(6, "task6");
        /**
         * 此处可以一步步打开看执行结果是不是符合上面注释所说的情况。
         */
        pool.execute(task1);
        pool.execute(task2);
        pool.execute(task3);
        pool.execute(task4);
        // pool.execute(task5);
        // pool.execute(task6);
        pool.shutdown();
    }
}

创建了一个自定义的线程池。

此处我们可以把任务一个一个加入到线程池中去验证上述情况看是否正确。

1.放入task1的时候马上执行，然后休眠5s关闭线程池。

2.放入task1和task2的时候我们发现，此时task1先执行，然后task2等待5s执行，然后等待5s线程池调用shutdown()方法关闭。

3.放入3个任务和4个的时候发现都是一次睡眠等待执行，关闭。

4.放入5个的时候我们发现线程1和线程5是同时执行的。然后依次执行task2,3,4.此时我们coreSize是1队列是满的，此时会创建一个线程。因为是5个任务，队列是满的，并且这种情况maxSize还可以创建一个线程执行，所有1和5是同时打印的，然后按照顺序依次执行。

5.放入6个任务的时候我们发现1和5执行完之后task6会抛出个异常不去执行，然后执行2.3.4.

由此可以验证我们上面说的结论。

2.在使用无界队列的时候：

LinkedBlockingQueue与有界队列相比，除非系统资源耗尽，否则无界队列不存在任务入队失败的情况，若系统的线程数小于corePoolSize时，则新建线程执行corePoolSize，当达到corePoolSize后，则把多余的任务放入队列中等待执行若任务的创建和处理的速速差异很大，无界队列会保持快速增长，直到耗尽系统内存为之，对于无界队列的线程池maximumPoolSize并无真实用处。

无界队列这个很好理解，此处就不做代码说明。