ThreadPoolExecutor

ThreadPoolExecutor

package com.zhw.learning.thread;

import java.util.concurrent.*;

/**
 * @author zhw
 */
public class ThreadPoolExecutorTest {

    public static void main(String[] args) {

        /**
         * 创建线程池
         * java.util.concurrent.ThreadPoolExecutor有多个构造方法，
         * 我们拿参数最多的构造方法来举例，
         * 以下是阿里巴巴代码规范中给出的创建线程池的范例
         *
         * corePoolSize:
         * 线程池核心池大小：用于设定 thread pool 需要时刻保持的最小 core threads 的数量，
         * 即便这些 core threads 处于空闲状态啥事都不做也不会将它们回收掉
         * maximumPoolSize:
         * 线程池最大线程数量：用于限定 pool 中线程数的最大值。
         * 如果你自己构造了 pool 且传入了一个 Unbounded 的 queue 且没有设置它的 capacity，
         * 那么不好意思，最大线程数会永远 <= corePoolSize，maximumPoolSize 变成了无效的
         * keepAliveTime:
         * 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间(当线程空闲时间达到keepAliveTime，该线程会退出)
         * TimeUnit:
         * 上一个参数的单位
         * workQueue:
         * 用来储存等待执行任务的队列：该线程池中的任务队列：维护着等待执行的 Runnable 对象。
         * 当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务
         *
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                5,
                200,
                0L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingDeque<>(1024),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

        /**
         *  等待执行的runnable
         */
        Runnable runnable = () -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        // 启动的任务数量
        int counts = 1224;
        for (int i = 0; i < counts; i++) {
            threadPoolExecutor.execute(runnable);
        }
        // 监控线程池执行情况的代码
        ThreadPoolExecutor tpe =  threadPoolExecutor;
        while (true) {
            System.out.println();

            int queueSize = tpe.getQueue().size();
            System.out.println("当前排队线程数：" + queueSize);

            int activeCount = tpe.getActiveCount();
            System.out.println("当前活动线程数：" + activeCount);

            long completedTaskCount = tpe.getCompletedTaskCount();
            System.out.println("执行完成线程数：" + completedTaskCount);

            long taskCount = tpe.getTaskCount();
            System.out.println("总线程数：" + taskCount);

            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

}

counts <= corePoolSize
所有的任务均为核心线程执行，没有任何 Runnable 被添加到 workQueue中
corePoolSize < counts <= corePoolSize + workQueue.size()
所有任务均为核心线程执行，当核心线程处于繁忙状态，则将任务添加到 workQueue 中等待
corePoolSize + workQueue.size() < counts <= maximumPoolSize + workQueue.size()
corePoolSize 个线程由核心线程执行，超出队列长度 workQueue.size() 的任务，将另启动非核心线程执行
counts > maximumPoolSize + workQueue.size()
将会报异常java.util.concurrent.RejectedExecutionException