Java线程池ThreadPoolExecutor参数解析

我不是女神ヾ 2022-06-02 04:54 296阅读 0赞

## 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();
                    }
           });
    }

##### 运行结果： #####

![Center][]

##### 结果分析： #####

从图中结果可以看到任务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();
                    }
            });
    }

##### 运行结果： #####

![Center 1][]

##### 结果分析： #####

从图中结果可以看出放入任务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();
                    }
            });
    }

#### 运行结果： ####

![Center 2][]

##### 结果分析： #####

图中结果可以看出任务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();
                    }
            });
    }

#### 运行结果： ####

![Center 3][]

##### 结果分析： #####

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

[JDK1.8ThreadPoolExecutor源码分析][JDK1.8ThreadPoolExecutor]

[Center]: /images/20220602/70a1f516b62749e3bf4729fa23589927.png
[Center 1]: /images/20220602/fb388237d35645dfbb64b157c3634742.png
[Center 2]: /images/20220602/4a42b17116b348359c830907bc983410.png
[Center 3]: /images/20220602/3bad493fc63346e897c96b65c6c3816a.png
[JDK1.8ThreadPoolExecutor]: https://www.cnblogs.com/leesf456/p/5585627.html