Java线程池之ThreadPoolExecutor的使用

以下是自定义线程池，使用了有界队列，自定义ThreadFactory和拒绝策略的demo：

import java.io.IOException;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 以下是自定义线程池，使用了有界队列，自定义ThreadFactory和拒绝策略的demo
 *
 * @author zsyoung@qq.com
 * @date 2019/3/3 16:40
 */
public class CustomThreadPoolExecutor {

    public static void main(String[] args) throws IOException {
        //核心线程池大小
        int corePoolSize = 2;
        //最大线程池大小
        int maximumPoolSize = 4;
        //线程最大空闲时间
        long keepAliveTime = 10;
        //时间单位
        TimeUnit unit = TimeUnit.SECONDS;
        //表示存放任务的队列（存放需要被线程池执行的线程队列）
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);
        //线程创建工厂
        ThreadFactory threadFactory = new NameThreadFactory();
        //拒绝策略（添加任务失败后如何处理该任务）
        RejectedExecutionHandler handler = new MyIgnorePolicy();

        ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);

        //预启动所有核心线程
        executor.prestartAllCoreThreads();

        for (int i = 1; i <= 10; i++) {
            MyTask task = new MyTask(i);
            executor.execute(task);
        }

    }

    /**
     * 构建自己的线程工厂类，这样你就可以方便的设置线程名字啦。
     * 创建线程或线程池时请指定有意义的线程名称，方便出错时回溯。
     * 创建线程池的时候请使用带ThreadFactory的构造函数，
     * 并且提供自定义ThreadFactory实现或者使用第三方实现。
     */
    public static class NameThreadFactory implements ThreadFactory {
        private final AtomicInteger mThreadNum = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "my-thread-" + mThreadNum.getAndIncrement());
            System.out.println(t.getName() + "has been created");
            return t;
        }
    }

    /**
     * 拒绝策略（添加任务失败后如何处理该任务）
     */
    public static class MyIgnorePolicy implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            doLog(r, executor);
        }

        private void doLog(Runnable r, ThreadPoolExecutor executor) {
            //可以做日志记录
            System.err.println(r.toString() + " rejected");
            System.out.println("completedTaskCount: " + executor.getCompletedTaskCount());
        }
    }

    /**
     * 构建自己的任务类，添加任务内容
     */
    public static class MyTask implements Runnable {
        private int taskNum;

        MyTask(int num) {
            this.taskNum = num;
        }

        @Override
        public void run() {
            System.err.println("正在执行task " + this.taskNum);
            try {
                //让任务执行慢点
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.err.println("task " + taskNum + "执行完毕");
        }

        public int getTaskNum() {
            return taskNum;
        }

        @Override
        public String toString() {
            return "MyTask [name=" + taskNum + "]";
        }
    }
}

输出结果如下：

正在执行task 1
my-thread-1has been created
正在执行task 2
my-thread-2has been created
MyTask [name=7] rejected
my-thread-3has been created
正在执行task 3
my-thread-4has been created
正在执行task 5
MyTask [name=8] rejected
completedTaskCount: 0
MyTask [name=9] rejected
completedTaskCount: 0
MyTask [name=10] rejected
completedTaskCount: 0
completedTaskCount: 0
task 1执行完毕
正在执行task 4
task 2执行完毕
正在执行task 6
task 3执行完毕
task 5执行完毕
task 4执行完毕
task 6执行完毕

其中线程线程1-4先占满了核心线程和最大线程数量，然后5、6线程进入等待队列，7-10
线程被直接忽略拒绝执行，等1-4线程中有线程执行完后通知5、6线程继续执行。

rejectedTaskNums = totalTaskNums - (Max(maximunPoolSize, workQueue) + corePoolSize)
被拒绝任务数量 = 总任务数量 - (Max(最大线程池大小，等待队列大小）+ 核心线程池大小))

总结，通过自定义线程池，我们可以更好的让线程池为我们所用，更加适应我的实际场景。