1. 介绍

1.1. 简介

• 线程池：一种线程使用模式。线程过多会带来调度开销，进而影响性能。而线程池维护着多个线程，等待着管理者分配可并发执行的任务。避免了在处理短时间任务时创建与销毀线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。
• 特点
  • 降低资源消耗：通过重复利用已创建的线程降低程创建和销毀造成的销耗。
  • 提高响应速度：当任务到达时，任务可以不需要等待线程创建就能立即执行。
  • 提高线程的可管瑆性：线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

1.2. 工作流程图

2. 线程池参数介绍

public ThreadPoolExecutor(int corePoolSize,  // 核心线程数
                              int maximumPoolSize,  // 最大线程数
                              long keepAliveTime,  // 空闲线程存活时间
                              TimeUnit unit,  // 时间单位
                              BlockingQueue<Runnable> workQueue,  // 阻塞队列
                              ThreadFactory threadFactory,  // 线程工厂
                              RejectedExecutionHandler handler)  // 拒绝策略
1
2
3
4
5
6
7

• corePoolSize：核心线程数，线程池中的常驻核心线程数
  • 在创建线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务
  • 当线程池中的线程数目达到corePoolSize后，就会把到达的队列放到缓存队列中
• maximumPoolSize：线程池能够容纳同时执行的最大线程数
  • 相当有扩容后的线程数，这个线程池能容纳的最多线程数
• keepAliveTime：多余的空闲线程存活时间
  • 当线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime值时，多余的空闲线程会被销毁，直到只剩下corePoolSize个线程为止
  • 默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用
• unit：keepAliveTime的单位
• workQueue：任务队列，被提交的但未被执行的任务将加入队列
• threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程池 一般用默认即可
• handler：拒绝策略，表示当队列满了并且工作线程大于线程池的最大线程数（maximumPoolSize）时，如何来拒绝请求执行的Runnable的策略

2.1. 阻塞队列

红色为常用的阻塞队列

2.2. 拒绝策略

• AbortPolicy：默认，直接抛出RejectedExcutionException异常，阻止系统正常运行
• DiscardPolicy：直接丢弃任务，不予任何处理也不抛出异常，如果运行任务丢失，这是一种好方案
• CallerRunsPolicy：该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者
• DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务

3. 常用线程池

3.1. newCachedThreadPool

缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量，可以进行自动线程回收

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(
            0,  // 核心线程数：0
            Integer.MAX_VALUE,  // 最大线程数：Integer.MAX_VALUE
            60L, // 空闲线程存活时间：60s
            TimeUnit.SECONDS,  //单位：秒
            new SynchronousQueue<Runnable>()  // 阻塞队列：SynchronousQueue
    ); 
}
1
2
3
4
5
6
7
8
9

3.2. newFixedThreadPool

创建固定大小的线程池

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(
            nThreads,  // 核心线程数：自定义数量
            nThreads,  // 最大线程数：自定义数量
            0L,  // 空闲线程存活时间：0
            TimeUnit.MILLISECONDS,  //单位：毫秒
            new LinkedBlockingQueue<Runnable>()  // 阻塞队列：LinkedBlockingQueue
    );
}
1
2
3
4
5
6
7
8
9

3.3. newSingleThreadExecutor

线程池中只有一个线程

public static ExecutorService newSingleThreadExecutor() {
    return new Executors.FinalizableDelegatedExecutorService(
            new ThreadPoolExecutor(
                    1,  // 核心线程数：1 
                    1,  // 最大线程数：1
                    0L,  // 空闲线程存活时间：0 
                    TimeUnit.MILLISECONDS,  //单位：毫秒
                    new LinkedBlockingQueue<Runnable>()  // 阻塞队列：LinkedBlockingQueue
            )
    );
}
1
2
3
4
5
6
7
8
9
10
11

3.4. 自定义

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
        int corePoolSize,
        int maximumPoolSize,
        long keepAliveTime,
        TimeUnit unit,
        BlockingQueue<Runnable> workQueue,
        ThreadFactory threadFactory,
        RejectedExecutionHandler handler
)
1
2
3
4
5
6
7
8
9