24.线程池工具类

1.线程池的工厂对象

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 创建线程池的工厂对象
 *
 * @author zlx
 * @date 2022/01/26 10:31
 **/
public class CustomThreadFactory implements ThreadFactory {

    private final String poolName;

    public CustomThreadFactory(String poolName) {
        this.poolName = poolName;
    }

    private final AtomicInteger count = new AtomicInteger(0);

    /**
     * 该方法用来创建线程,给线程命名
     */
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        String nowThreadName = poolName + count.addAndGet(1);
        t.setName(nowThreadName);
        return t;
    }
}

2.线程池饱和策略

import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 线程池饱和策略
 *
 * @author zlx
 * @date 2022/01/26 10:29
 **/
public class ThreadRejectedExecutionHandler implements RejectedExecutionHandler {

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
    }

    /**
     * 饱和策略一：调用者线程执行策略
     * 在该策略下，在调用者中执行被拒绝任务的run方法。除非线程池showdown，否则直接丢弃线程
     */
    public static class CallerRunsPolicy extends ThreadRejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            //判断线程池是否在正常运行，如果线程池在正常运行则由调用者线程执行被拒绝的任务。如果线程池停止运行，则直接丢弃该任务
            if (!executor.isShutdown()) {
                r.run();
            }
        }
    }


    /**
     * 饱和策略二：终止策略
     * 在该策略下，丢弃被拒绝的任务，并抛出拒绝执行异常
     */
    public static class AbortPolicy extends ThreadRejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            throw new RejectedExecutionException("请求任务：" + r.toString() + "，线程池负载过高执行饱和终止策略！");
        }
    }


    /**
     * 饱和策略三：丢弃策略
     * 在该策略下，什么都不做直接丢弃被拒绝的任务
     */
    public static class DiscardPolicy extends ThreadRejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        }
    }

    /**
     * 饱和策略四：弃老策略
     * 在该策略下，丢弃最早放入阻塞队列中的线程，并尝试将拒绝任务加入阻塞队列
     */
    public static class DiscardOldestPolicy extends ThreadRejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            //判断线程池是否正常运行，如果线程池正常运行则弹出（或丢弃）最早放入阻塞队列中的任务，并尝试将拒绝任务加入阻塞队列。如果线程池停止运行，则直接丢弃该任务
            if (!executor.isShutdown()) {
                executor.getQueue().poll();
                executor.execute(r);
            }
        }
    }
}

3.线程池工具类

package com.zlx.java.util.threadPool;

import java.util.List;
import java.util.concurrent.*;

/**
 * 单例的线程池工具类
 *
 * @author zlx
 * @date 2022/01/26 10:28
 **/
public class ThreadPoolUtils {

    /**
     * 系统可用计算资源
     */
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();

    /**
     * 核心线程数
     */
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));

    /**
     * 最大线程数
     */
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;

    /**
     * 空闲线程存活时间
     */
    private static final int KEEP_ALIVE_SECONDS = 30;

    /**
     * 工作队列
     */
    private static final BlockingQueue<Runnable> POOL_WORK_QUEUE = new LinkedBlockingQueue<>(128);

    /**
     * 工厂模式
     */
    private static final CustomThreadFactory MY_THREAD_FACTORY = new CustomThreadFactory("CUSTOM-POOL");

    /**
     * 饱和策略
     */
    private static final ThreadRejectedExecutionHandler THREAD_REJECTED_EXECUTION_HANDLER = new ThreadRejectedExecutionHandler.CallerRunsPolicy();

    /**
     * 线程池对象
     */
    private static final ThreadPoolExecutor THREAD_POOL_EXECUTOR;

    /**
     * 声明式定义线程池工具类对象静态变量，在所有线程中同步
     */
    private static volatile ThreadPoolUtils threadPoolUtils = null;


    //初始化线程池静态代码块
    static {
        THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(
                //核心线程数
                CORE_POOL_SIZE,
                //最大线程数
                MAXIMUM_POOL_SIZE,
                //空闲线程执行时间
                KEEP_ALIVE_SECONDS,
                //空闲线程执行时间单位
                TimeUnit.SECONDS,
                //工作队列（或阻塞队列）
                POOL_WORK_QUEUE,
                //工厂模式
                MY_THREAD_FACTORY,
                //饱和策略
                THREAD_REJECTED_EXECUTION_HANDLER
        );
    }


    /**
     * 线程池工具类空参构造方法
     */
    private ThreadPoolUtils() {
    }

    /**
     * 获取线程池工具类实例
     */
    public static ThreadPoolUtils getNewInstance() {
        if (threadPoolUtils == null) {
            synchronized (ThreadPoolUtils.class) {
                if (threadPoolUtils == null) {
                    threadPoolUtils = new ThreadPoolUtils();
                }
            }
        }
        return threadPoolUtils;
    }


    /**
     * 执行线程任务
     *
     * @param runnable 任务线程
     */
    public void executor(Runnable runnable) {
        THREAD_POOL_EXECUTOR.execute(runnable);
    }

    /**
     * 获取线程池状态
     *
     * @return 返回线程池状态
     */
    public boolean isShutDown() {
        return THREAD_POOL_EXECUTOR.isShutdown();
    }

    /**
     * 停止正在执行的线程任务
     *
     * @return 返回等待执行的任务列表
     */
    public List<Runnable> shutDownNow() {
        return THREAD_POOL_EXECUTOR.shutdownNow();
    }

    /**
     * 关闭线程池
     */
    public void showDown() {
        THREAD_POOL_EXECUTOR.shutdown();
    }


    /**
     * 关闭线程池后判断所有任务是否都已完成
     */
    public boolean isTerminated() {
        return THREAD_POOL_EXECUTOR.isTerminated();
    }
}

4.任务线程

import java.util.concurrent.TimeUnit;

/**
 * 任务线程
 * @author zlx
 * @date 2022/01/26 11:04
 **/
public class ThreadTask implements Runnable {
    @Override
    public void run() {
        System.out.println("thread task：" + this.toString() + "，task start！");
    }
}

5.测试类

/**
 * 测试类
 *
 * @author zlx
 * @date 2022/01/26 10:31
 **/
public class Test {

    public static final ThreadPoolUtils THREAD_POOL_INSTANCE = ThreadPoolUtils.getNewInstance();

    public static void main(String[] args) {
        THREAD_POOL_INSTANCE.executor(new ThreadTask());
        THREAD_POOL_INSTANCE.showDown();
    }
}