Java线程池ThreadPoolExecutor参数解析

ThreadPoolExecutor构造函数

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

1.corePoolSize

核心线程池大小如果运行的线程少于corePoolSize，则创建新线程来处理请求，即使其他辅助线程是空闲的。

2.maximumPoolSize

表示最大线程池的大小，如果运行的线程多于corePoolSize 而少于 maximumPoolSize，则仅当阻塞队列满时才创建新线程。如果设置的corePoolSize和 maximumPoolSize相同，则创建了固定大小的线程池（例如newFixThreadPool）。

3.keepAliveTime 

线程池大小超过corePoolSize时，超过部分的空闲线程存活的时间，TimeUnit 时间单位。

4.ThreadFactory

创建线程的线程工厂。

5.BlockingQueue

用于保存等待执行的任务的阻塞队列。

ArrayBlockingQueue

一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。

LinkedBlockingQueue

一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。

SynchronousQueue

一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。

PriorityBlockingQueue

一个具有优先级的无限阻塞队列。

PriorityBlockingQueue里面存储的对象必须是实现Comparable接口。队列通过这个接口的compare方法确定对象的priority。

PriorityBlockingQueue队列添加新元素时候不是将全部元素进行顺序排列，而是从某个指定位置开始将新元素与之比较，一直比到队列头，这样既能保证队列头一定是优先级最高的元素，又能减少排序带来的性能消耗（个人判断，仅供参考），可以查看PriorityBlockingQueue源码，添加元素有调用一个方法是PriorityQueue.siftUpUsingComparator（或siftUpComparable）。

这个方法里有个排序算法不是全部排序。

private void siftUpComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (key.compareTo((E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = key;
}

但是这样会出现一个情况，取完队列头时候，后面的剩余的元素不是排序的，岂不是不符合要求了，继续查看源码，发现每取一个头元素时候，都会对剩余的元素做一次调整，这样就能保证每次队列头的元素都是优先级最高的元素，查看取元素时候调用的一个方法PriorityQueue.：

private void siftDown(int k, E x) {
        if (comparator != null)
            siftDownUsingComparator(k, x);
        else
            siftDownComparable(k, x);
    }
private void siftDownUsingComparator(int k, E x) {
	int half = size >>> 1;
	while (k < half) {
		int child = (k << 1) + 1;
		Object c = queue[child];
		int right = child + 1;
		if (right < size &&
			comparator.compare((E) c, (E) queue[right]) > 0)
			c = queue[child = right];
		if (comparator.compare(x, (E) c) <= 0)
			break;
		queue[k] = c;
		k = child;
	}
	queue[k] = x;
}

6.RejectedExecutionHandler

CallerRunsPolicy

在调用execute的线程里面执行此command，会阻塞入口

实例代码：

//在调用execute的线程里面执行此command，会阻塞入口
ThreadPoolExecutor threadPoolExecutor3 = new ThreadPoolExecutor(1, 1,
                1000, TimeUnit.MICROSECONDS, new LinkedBlockingDeque<>(2),
                new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 1; i <= 4; i++) {
            final int count = i;
            System.out.println("execute" + i);
            threadPoolExecutor3.execute(() -> {
                try {
                    Thread.sleep(1000);//此任务耗时1s
                    System.out.println("线程" + Thread.currentThread().getName() + "完成任务："
                            + count + "   时间为：" + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
       });
}

运行结果：

结果分析：

从图中结果可以看到任务4是mian线程执行的且为立即执行的，由于不用新建线程执行，所以比第一个任务还要先执行完。

AbortPolicy

默认的阻塞策略，不执行此任务，而且直接抛出一个运行时异常。

实例代码：

ThreadPoolExecutor threadPoolExecutor3 = new ThreadPoolExecutor(1, 1,
                1000, TimeUnit.MICROSECONDS, new LinkedBlockingDeque<>(2),
                new ThreadPoolExecutor.AbortPolicy());
        for (int i = 1; i <= 4; i++) {
            final int count = i;
            System.out.println("execute" + i);
            threadPoolExecutor3.execute(() -> {
                try {
                    Thread.sleep(1000);//此任务耗时1s
                    System.out.println("线程" + Thread.currentThread().getName() + "完成任务："
                            + count + "   时间为：" + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        });
}

运行结果：

结果分析：

从图中结果可以看出放入任务4时，抛出异常。

DiscardOldestPolicy

该策略将丢弃阻塞队列中即将执行的任务，并尝试执行当前任务。

实例代码：

ThreadPoolExecutor threadPoolExecutor3 = new ThreadPoolExecutor(1, 1,
                1000, TimeUnit.MICROSECONDS, new LinkedBlockingDeque<>(2),
                new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 1; i <= 4; i++) {
            final int count = i;
            System.out.println("execute" + i);
            threadPoolExecutor3.execute(() -> {
                try {
                    Thread.sleep(1000);//此任务耗时1s
                    System.out.println("线程" + Thread.currentThread().getName() + "完成任务："
                            + count + "   时间为：" + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        });
}

运行结果：

结果分析：

图中结果可以看出任务1正在执行时，2,3进入阻塞队列，4来的时候，阻塞队列已满，所以把在队列头的任务2丢弃。

DiscardPolicy

该策略将丢弃当前任务。

实例代码：

ThreadPoolExecutor threadPoolExecutor3 = new ThreadPoolExecutor(1, 1,
                1000, TimeUnit.MICROSECONDS, new LinkedBlockingDeque<>(2),
                new ThreadPoolExecutor.DiscardPolicy());
        for (int i = 1; i <= 4; i++) {
            final int count = i;
            System.out.println("execute" + i);
            threadPoolExecutor3.execute(() -> {
                try {
                    Thread.sleep(1000);//此任务耗时1s
                    System.out.println("线程" + Thread.currentThread().getName() + "完成任务："
                            + count + "   时间为：" + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        });
}

运行结果：

结果分析：

可以看到任务1，和队列中的任务2、3都执行了，超出队列的任务4被直接丢弃。

JDK1.8ThreadPoolExecutor源码分析