【八股学习】JUC —— 线程池_线程池juv-优快云博客

本文链接：https://blog.youkuaiyun.com/messiy727/article/details/145279123

线程池

为什么用线程池 / 线程池的好处

关键词：池化技术
好处：

降低资源消耗：重复利用已创建线程，避免创建销毁的消耗
提高响应速度：不用等待线程创建，就可以执行任务
提高线程的可管理性：线程不能无限制创建

线程池创建方法

1、通过ThreadPoolExecutor构造函数来创建（推荐）

常见参数如下：

    /**
     * 用给定的初始参数创建一个新的ThreadPoolExecutor。
     */
    public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量
                              int maximumPoolSize,//线程池的最大线程数
                              long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间
                              TimeUnit unit,//时间单位
                              BlockingQueue<Runnable> workQueue,//任务队列，用来储存等待执行任务的队列
                              ThreadFactory threadFactory,//线程工厂，用来创建线程，一般默认即可
                              RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务
                               ) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

corePoolSize：任务队列未达到队列容量，最大可以同时运行的线程数量。一般不会被回收，allowCoreThreadTimeOut(boolean value)，设为 true 就会在 keepAliveTime之后被回收
maximumPoolSize：任务队列中存放的任务达到队列容量时，可以同时运行的线程数量
workQueue：新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中
keepAliveTime：存在非核心线程时，这些线程在空闲后等待超过该时间才会被回收销毁
unit：keepAliveTime参数时间单位
threadFactory：executor 创建新线程的时候会用到
handler：拒绝策略

拒绝策略

当线程已经达到最大线程数，并且队列也已经放满了任务时：

ThreadPoolExecutor.AbortPolicy（默认）：抛出异常来拒绝新任务
ThreadPoolExecutor.DiscardPolicy：不处理新任务直接丢弃
ThreadPoolExecutor.DiscardOldestPolicy：丢弃最早未处理的任务请求
ThreadPoolExecutor.CallerRunsPolicy（不丢弃任务的选择）：直接在调用execute方法的线程中运行被拒绝的任务。会影响程序的整体性能。

阻塞队列

新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。

容量为 Integer.MAX_VALUE 的 LinkedBlockingQueue：有界阻塞队列：有固定大小
ArrayBlockingQueue（有界阻塞队列）：底层由数组实现，容量一旦创建，就不能修改
SynchronousQueue（同步队列）：没有容量，不存储元素，有任务就让空闲线程或新建线程执行
DelayedWorkQueue（延迟队列）：内部使用堆按照延迟的时间长短对任务排序，元素满了就会进行扩容，所以只能创建核心线程数的线程

线程池命名 ThreadFactory⭐

1、利用 guava 的 ThreadFactoryBuilder

ThreadFactory threadFactory = new ThreadFactoryBuilder()
                        .setNameFormat(threadNamePrefix + "-%d")
                        .setDaemon(true).build();
ExecutorService threadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.MINUTES, workQueue, threadFactory);

2、自己实现ThreadFactory
创建一个类实现 ThreadFactory 接口，重写newThread方法，返回一个setName之后的Thread即可。

2、通过 Executor 框架的工具类 Executors 来创建

FixedThreadPool：固定线程数量的线程池。新任务提交时如果有空闲线程立即执行，没有空闲线程则为暂存在任务队列中，等待空闲线程执行
SingleThreadExecutor：只有一个线程的线程池。多余任务存在任务队列，按照 FIFO 顺序被执行。
CachedThreadPool：根据实际情况调整线程数量的线程池。有空闲线程则执行任务，否则创建新线程，待执行完成后，返回线程池进行复用。
ScheduledThreadPool：给定的延迟后运行任务或者定期执行任务的线程池

不推荐使用该方法创建线程池！⭐

FixedThreadPool和SingleThreadExecutor，使用有界阻塞队列：LinkedBlockingQueue，队列最大长度为Integer.MAX_VALUE，可能会堆积请求OOM
CachedThreadPool，使用同步队列：SynchronousQueue，允许创建的线程数量为Integer.MAX_VALUE，线程执行任务慢会创建大量的线程导致OOM
ScheduledThreadPool和SingleThreadScheduledExecutor，使用无界延迟阻塞队列DelayedWorkQueue，任务队列最大长度为Integer.MAX_VALUE，堆积大量请求导致OOM