【并发编程】线程池

news2024/10/7 6:37:52

背景

线程的创建和销毁都需要很大的开销，当线程数量过大，并且线程生命周期短。这时候线程频繁地创建和销毁就很没有必要。

在 Java 中可以通过线程池来解决此问题。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。

在 JDK5 之前，我们必须手动实现自己的线程池，从 JDK5 开始，Java 内置支持线程池。在 JDK5 版本中增加了内置线程池实现 ThreadPoolExecutor，同时提供了Executors 来创建不同类型的线程池。Executors 中提供了以下常见的线程池创建方法：

newSingleThreadExecutor：一个单线程的线程池。如果因异常结束，会再创建一个新的，保证按照提交顺序执行。

newFixedThreadPool：创建固定大小的线程池。根据提交的任务逐个增加线程，直到最大值保持不变。如果因异常结束，会新创建一个线程补充。

newCachedThreadPool：创建一个可缓存的线程池。会根据任务自动新增或回收线程。

虽然在 JDK 中提供 Executors 类来支持以上类型的线程池创建，但通常情况下不建议开发人员直接使用（见《阿里巴巴 java 开发规范》并发处理）。

线程池优点:

重复利用线程，降低线程创建和销毁带来的资源消耗。
统一管理线程，线程的创建和销毁都由线程池进行管理。
提高响应速度，线程创建已经完成，任务来到可直接处理，省去了创建时间。

ThreadPoolExecutor 类

ThreadPoolExecutor 继承了 AbstractExecutorService 类，并提供了四个构造器，事实上，通过观察每个构造器的源码具体实现，发现前面三个构造器都是调用的第四个构造器进行的初始化工作。

核心源码

public class ThreadPoolExecutor extends AbstractExecutorService {
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
    
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }
    
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }
    
    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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
}

构造器中各个参数的含义

corePoolSize：核心池的大小。在创建了线程池后，默认情况下，在创建了线程池后，线程池中的线程数为 0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到 corePoolSize 后，就会把到达的任务放到缓存队列当中;除非调用了prestartAllCoreThreads()或者 prestartCoreThread()方法，在没有任务到来之前就创建corePoolSize 个线程或者一个线程。

maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；

keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于 corePoolSize 时，keepAliveTime 才会起作用，直到线程池中的线程数不大于 corePoolSize，即当线程池中的线程数大于 corePoolSize 时，如果一个线程空闲的时间达到 keepAliveTime，则会终止，直到线程池中的线程数不超过 corePoolSize。

unit：参数 keepAliveTime 的时间单位，有 7 种取值，在 TimeUnit 类中有 7种静态属性:

TimeUnit.NANOSECONDS;          //纳秒

TimeUnit.MICROSECONDS;         //微秒

TimeUnit.MILLISECONDS;         //毫秒

TimeUnit.SECONDS;              //秒

TimeUnit.MINUTES;              //分钟

TimeUnit.HOURS;                //小时

TimeUnit.DAYS;                 //天

workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很

重要，会对线程池的运行过程产生重大影响

threadFactory：线程工厂，主要用来创建线程；

handler：表示当拒绝处理任务时的策略 ;

线程池的执行

创建完成 ThreadPoolExecutor 之后，当向线程池提交任务时，通常使用 execute 方法。execute 方法的执行流程图如下：

如果线程池中存活的核心线程数小于线程数 corePoolSize 时，线程池会创建一个核心线程去处理提交的任务。
如果线程池核心线程数已满，即线程数已经等于 corePoolSize，一个新提交的任务，会被放进任务队列workQueue 排队等待执行。3. 当线程池里面存活的线程数已经等于 corePoolSize 了,并且任务队列workQueue也满，判断线程数是否达到 maximumPoolSize，即最大线程数是否已满，如果没到达，创建一个非核心线程执行提交的任务。
如果当前的线程数达到了 maximumPoolSize，还有新的任务过来的话，直接采用拒绝策略处理。