线程池

线程池基本介绍参考链接：https://blog.csdn.net/a1275302036/article/details/116662394

创建线程池参数

public ThreadPoolExecutor(int corePoolSize,
                         int maximumPoolSize,
                         long keepAliveTime,
                         TimeUnit unit,
                         BlockingQueue<Runnable> workQueue,
                         ThreadFactory threadFactory,
                         RejectedExecutionHandler handler) {
                         // 省略相关代码
}

 

corePoolSize：核心线程数
maximumPoolSize：最大线程数，（最大线程数包含核心线程数）
keepAliveTime：最大线程数的存活时间。（核心线程即便无任务也不会清除，其他线程都是有存货时间的 这就是存活时间）
unit: keepAliveTime的单位
workQueue：阻塞（等待）队列
threadFactory :创建线程的工厂，主要是创建线程设置优先级和是否为守护线程。
handler：拒绝策略

 

线程池工具类

package com.jlpay.agent.query.enums;

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

/**
 * 固定大小线程池工具
 *
 * @author heyaolei
 * @since 2022/3/23
 */
public enum FixedThreadPoolUtil {

    /**
     * 单例-固定线程池工具
     */
    INSTANCE;

    private ExecutorService pool;

    FixedThreadPoolUtil() {
        LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(5_000);
        pool = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, queue, new ThriftThreadFactory());
    }

    static class ThriftThreadFactory implements ThreadFactory {
        private static final AtomicInteger POOL_NUMBER = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        ThriftThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
            namePrefix = "customized-thread-pool-" + POOL_NUMBER.getAndIncrement() + "-thread-";
        }

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(),
                    0);

 　　　　　　//设置非守护线程
           if (t.isDaemon()) {
                t.setDaemon(false);
            }
　　　　　　　　//设置固定优先级
            if (t.getPriority() != Thread.NORM_PRIORITY) {
                t.setPriority(Thread.NORM_PRIORITY);
            }
            return t;
        }
    }

    /**
     * 执行任务
     *
     * @param task 任务
     */
    public void execute(Runnable task) {
        pool.execute(task);
    }
}

创建线程池

        FixedThreadPoolUtil.INSTANCE.execute(() -> {
}

 

 

阻塞队列：

概念：任务进来的太多，已经超过了核心线程数的时候就要阻塞排队。

参考：https://www.cnblogs.com/Mateo-dengmin/p/15855151.html

LinkedBlockingQueue:    可以存储数据，可以设置容量 ，超过设置的容量后阻塞。 如果不设置容量就是无限大。

SynchronousQueue:       不可以存储数据，生产一条消息之后需要消费之后再生产。如果生产完没有消费  生产会阻塞，如果消费后没有生产  消费阻塞。

DelayedWorkQueue:      根据任务延迟时间排队。

 

拒绝策略：

概念：当线程池中 线程数量等于最大线程数量 且 任务队列已满时，则会执行线程池会对新增加的任务执行拒绝策略。

CallerRunsPolicy : 由调用线程处理

AbortPolicy ：丢弃任务，抛出RejectedExecutionException

DiscardPolicy: 丢弃任务，不抛出异常

DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）