Java多线程之深入学习线程池(Executor)

---

提示：以下是本篇文章正文内容，Java系列学习将会持续更新

一、线程池的作用

（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

回到目录…

二、ThreadPoolExecutor

所在包：
java.util.concurrent
已实现的接口：
Executor, ExecutorService
直接子类：
ScheduledThreadPoolExecutor

①构造方法

public ThreadPoolExecutor(int corePoolSize,  // 核心线程数
                          int maximumPoolSize, // 最大线程数 = 核心 + 临时
                          long keepAliveTime,  // 线程闲置超时时长
                          TimeUnit unit,       // 指定keepAliveTime时间单位
                          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) // 线程工厂

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler 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;
}

回到目录…

②嵌套类(拒绝策略)

当线程池的线程数达到最大线程数时，需要执行拒绝策略。
拒绝策略需要实现 RejectedExecutionHandler 接口，
并实现 rejectedExecution(Runnable r, ThreadPoolExecutor executor)方法。

不过 Executors 框架已经为我们实现了 4 种拒绝策略：

嵌套拒绝类	拒绝策略
AbortPolicy（默认）	丢弃任务并抛出 RejectedExecutionException 异常。
CallerRunsPolicy	由调用线程处理该任务。
DiscardPolicy	丢弃任务，但是不抛出异常。可以配合这种模式进行自定义的处理方式
DiscardOldestPolicy	丢弃队列最早的未处理任务，然后重新尝试执行任务。

回到目录…

③线程池的使用

public static void main(String[] args) {

    // 创建线程池
    ThreadPoolExecutor service = new ThreadPoolExecutor(
            6,
            10,
            10, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(3));

    // 创建任务
    Runnable task = new Runnable() {
        @Override
        public void run() {
            System.out.println("执行任务");
        }
    };

    // 向线程池提交任务
    service.execute(task);

    /** 关闭线程池 **/
    // 设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程
    threadPool.shutdown();
    // 设置线程池的状态为 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表
    threadPool.shutdownNow();
}

回到目录…

三、工作原理

①流程图

常见流程如下：
 ①提交任务后，先判断当前池中线程数是否小于 corePoolSize，如果小于，则创建新线程执行这个任务。
 ②否则，判断线程池任务队列是否已满，如果没有满，则添加任务到任务队列。
 ③否则，判断当前池中线程数是否大于 maximumPoolSize，如果大于则执行预设拒绝策略。
 ④否则，创建一个临时线程执行该任务，直至线程数达到maximumPoolSize，达到后执行预设拒绝策略。

回到目录…

②代码实现

MyThreadPoolExecutor类

import java.util.concurrent.*;
/**
 * 自己实现线程池
 */
public class MyThreadPoolExecutor implements Executor {

    // 核心线程最大数量
    private final int corePoolSize;
    // 最大线程数量
    private final int maxPoolSize;
    // 空闲时间
    private final long keepAliveTime;
    private final TimeUnit unit;
    // 任务队列
    private final BlockingQueue<Runnable> workQueue;
    // 线程工厂
    private final ThreadFactory threadFactory;

    // 当前核心线程数量
    private int curCorePoolSize;
    // 当前线程数量
    private int curPoolSize;

    // 构造方法
    public MyThreadPoolExecutor(int corePoolSize,
                                int maxPoolSize,
                                long keepAliveTime, TimeUnit unit,
                                BlockingQueue<Runnable> workQueue,
                                ThreadFactory threadFactory,
                                RejectedExecutionHandler handler) {
        this.corePoolSize = corePoolSize;
        this.maxPoolSize = maxPoolSize;
        this.keepAliveTime = keepAliveTime;
        this.unit = unit;
        this.workQueue = workQueue;
        this.threadFactory = threadFactory;
    }

    @Override
    public void execute(Runnable command) {
        // 1. 如果当前的核心线程数 < 最大核心线程数，就直接创建一个核心线程来执行任务
        if(curCorePoolSize < corePoolSize) {
            // 创建一个核心线程要做的工作
            Runnable job = new CoreJob(workQueue, command);
            // 创建核心线程，并分配任务
            Thread coreThread = threadFactory.newThread(job); // 通过线程工厂
            coreThread.setName("核心线程-" + curCorePoolSize);
            // 启动核心线程
            coreThread.start();
            // 核心线程一直在死循环中取任务，取不到任务就会进入阻塞状态。不会结束工作就不会被销毁。
            curCorePoolSize ++;
            curPoolSize ++;
        }else{
            // 2.将任务存放到任务队列中
            if(workQueue.offer(command)){
                // 这里用offer，不用put。因为我们需要立即得到结果(是否能放进去<=>是否需要临时线程)，而不是让主线程阻塞
                // 成功放入任务队列中
            }else {
                // 3.队列已满，创造临时线程执行任务
                if(curPoolSize < maxPoolSize){
                    Runnable job = new TemporaryJob(keepAliveTime, unit, workQueue, command);
                    Thread tmpThread = threadFactory.newThread(job);
                    tmpThread.setName("临时线程-" + (curPoolSize - corePoolSize));
                    tmpThread.start();
                    // 临时线程取不到任务就会break跳出循环结束，工作结束后会被自动销毁
                    curPoolSize ++;
                }else{
                    // 4. 已经达到最大线程数，此时采用拒绝策略
                    throw new RejectedExecutionException();
                }
            }
        }
    }
}

回到目录…

CoreJob类

import java.util.concurrent.BlockingQueue;
/**
 * 一个核心线程要进行的工作
 */
public class CoreJob implements Runnable {
    // 需要阻塞队列
    private final BlockingQueue<Runnable> workQueue;
    // 当前提交的任务
    private Runnable curCommand;

    CoreJob(BlockingQueue<Runnable> workQueue, Runnable curCommand) {
        this.workQueue = workQueue;
        this.curCommand = curCommand;
    }

    @Override
    public void run() {
        try {
            // 优先先把刚提交的任务先做掉了
            curCommand.run();
            // 这里设置 null 的意思是，不影响 curCommand 对象被 GC 时的回收
            curCommand = null;
            // 核心线程把手头工作做完后，会继续取任务、做任务
            while (!Thread.interrupted()) {
                // 这里用take，而不是poll。因为我们需要队列中没有任务时就要阻塞的效果
                Runnable command = workQueue.take();
                command.run();
            }
        } catch (InterruptedException ignored) {}
    }
}

回到目录…

TemporaryJob类

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
/**
 * 一个临时线程需要进行的工作
 */
public class TemporaryJob implements Runnable {
    // 需要阻塞队列
    private final BlockingQueue<Runnable> workQueue;
    private final long keepAliveTime;
    private final TimeUnit unit;
    private Runnable curCommand;

    TemporaryJob(long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, Runnable curCommand) {
        this.keepAliveTime = keepAliveTime;
        this.unit = unit;
        this.workQueue = workQueue;
        this.curCommand = curCommand;
    }

    @Override
    public void run() {
        try {
            curCommand.run();     // 优先先把刚提交的任务先做掉了
            curCommand = null;    // 这里设置 null 的意思是，不影响 curCommand 对象被 GC 时的回收

            // 一旦超过一定时间没有任务，临时工是需要退出的
            // 1. keepAliveTime + unit 记录起来
            // 2. 怎么就知道超过多久没有任务了？如果一定时间内都无法从队列中取出来任务，则认为摸鱼时间够了
            while (!Thread.interrupted()) {
                // 规定时间内取不出来就不取了
                Runnable command = workQueue.poll(keepAliveTime, unit);
                if (command == null) {
                    // 说明最大空闲时间内，没有取到任务，可以退出了
                    break;
                    // 退出后，该线程的任务就算结束了，系统会自动销毁该线程
                }
                command.run();
            }
        } catch (InterruptedException ignored) {}
    }
}

回到目录…

四、功能线程池 Executors

其实Executors已经为我们封装好了 4 种常见的功能线程池，如下：

①定长线程池（FixedThreadPool）

特点：只有核心线程，线程数量固定，执行完立即回收，任务队列为链表结构的有界队列。
应用场景：控制线程最大并发数。

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

示例:

// 应用示例：
ExecutorService service = Executors.newFixedThreadPool(10);

Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("执行任务！");
    }
};
service.execute(task);

②定时线程池（ScheduledThreadPool）

特点：核心线程数量固定，非核心线程数量无限，执行完闲置 10ms 后回收，任务队列为延时阻塞队列。
应用场景：执行定时或周期性的任务。

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

③可缓存线程池（CachedThreadPool）

特点：无核心线程，非核心线程数量无限，执行完闲置 60s 后回收，任务队列为不存储元素的阻塞队列。
应用场景：执行大量、耗时少的任务。

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

④单线程化线程池（SingleThreadExecutor）

特点：只有 1 个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列。
应用场景：不适合并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作，如数据库操作、文件操作等。

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

总结

 Executors 的 4 个功能线程池现在已经不建议使用了，而是建议直接通过使用Executor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

其实 Executors功能线程有如下弊端：
 ①功能固定，不够灵活。
 ②FixedThreadPool 和 SingleThreadExecutor：主要问题是堆积的请求处理队列均采用 LinkedBlockingQueue，可能会耗费非常大的内存，甚至 OOM(内存不够用)。
 ③CachedThreadPool 和 ScheduledThreadPool：主要问题是线程数最大数是 Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至 OOM。

回到目录…

---

总结:
提示：这里对文章进行总结：
以上就是今天的学习内容，本文是Java多线程的学习，认识了线程池的概念和作用，以及线程池的原理，如何自己实现线程池。了解了四种功能线程的用法。之后的学习内容将持续更新！！！