Java进阶笔记 线程池（类比银行业务来理解）

1. Java 线程池

线程池是一种多线程处理形式，处理过程中可以将任务（Runnable、Callable）添加到队列中，然后在创建线程后自动启动这些任务。

1.1. 线程池的特点

使用线程池可以根据系统的需求和硬件环境灵活的控制线程数量，且可以对所有线程进行统一管理，提高系统运行效率，降低系统运行压力。

• 线程和任务分离，提升线程重用性。
• 控制线程并发数量，降低服务器压力，统一管理所有线程。
• 复用已有线程，节省线程创建和销毁的时间，提升系统响应速度。

1.2. Java 中的线程池类

1.3. 线程池的最佳容量

【容量影响】

• 过小会导致程序不能充分地利用系统资源、容易导致饥饿。
• 过大会导致更多的线程上下文切换，占用更多内存。

【CPU密集型运算】

CPU总是处于繁忙状态。通常采用CPU核数+ 1能够实现最优的CPU利用率，+1是保证当线程由于页缺失故障（操作系统）或其它原因导致暂停时，额外的这个线程就能顶上去，保证CPU时钟周期不被浪费。

【I/O密集型运算】

CPU不总是处于繁忙状态。例如，当你执行业务计算时，这时候会使用CPU资源，但当你执行I/O操作时、远程RPC调用时，包括进行数据库操作时，这时候CPU就闲下来了，你可以利用多线程提高它的利用率。

【经验公式】

线程数=核数×期望CPU利用率×CPU总时间(计算时间+等待时间)CPU计算时间线程数 = \frac {核数×期望CPU利用率×CPU总时间(计算时间+等待时间)}{CPU计算时间}线程数=CPU计算时间核数×期望CPU利用率×CPU总时间(计算时间+等待时间)​

例如4核CPU计算时间是50%，其它等待时间是50%，期望CPU被100%利用，套用公式：4 × 100% × 100% ÷ 50% = 8。

例如4核CPU计算时间是10%，其它等待时间是90%，期望CPU被100%利用，套用公式：4 × 100% × 100% ÷ 10% = 40。

2. ThreadPoolExecutor

2.1. 线程池状态

ThreadPoolExecutor 使用 int 的高3位来表示线程池状态，低29位表示线程数量。

从数字上比较，TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING。

用一个原子变量 ctl 来存储是为了能在一次 CAS 操作中，既能修改状态，也能修改数量。

2.2. 基本原理

2.2.1. 构造方法

public ThreadPoolExecutor(
    int corePoolSize,			// 核心线程数（不会被销毁的线程数）
    int maximumPoolSize,		// 最大线程数（核心线程数 + 非核心线程数）
    long keepAliveTime,			// 非核心线程的生存时间
    TimeUnit unit,			// 非核心线程的生存时间单位
    BlockingQueue<Runnable> workQueue,	// 工作队列（需要自己设置队列的容量）
    ThreadFactory threadFactory,	// 线程工厂（可以为线程起个名字）
    RejectedExecutionHandler handler	// 饱和拒绝策略
)
复制代码

2.2.2. 组成部分

• 核心线程： 提交新任务时，首先检查已创建的核心线程数：
  • 如果数量未达到核心线程数，则新建一个核心线程，并且将这个任务交由这个核心线程执行。
  • 如果数量已达到核心线程数，则不会新建核心线程，而会将这个任务放入工作队列中。
• 工作队列： 当核心线程执行完一个任务后，会去工作队列中拉取一个新任务继续执行。一般是一个线程安全的有界阻塞队列。
• 非核心线程： 如果继续提交新任务，且工作队列中的任务数量已达到队列的最大容量，当前线程数没有超过最大线程数，则会新建一个非核心线程执行这个任务。（核心线程和非核心线程本质上它们没有什么区别）
• 线程生存时间： 非核心线程空闲之后，超过这个时间还没有任务执行，该线程结束。
• 饱和拒绝策略： 当工作队列已满，线程数也达到最大线程数时，线程池会根据饱和策略来执行后续操作。

2.2.3. 工作流程

【类比理解】

有一家银行（线程池），有两个固定窗口（核心线程数为2），3位工作人员（最大线程数为3），等候座位（任务队列），一个规则《超出银行最大接待能力处理办法》（饱和拒绝策略）：

• A客户（任务A）去银行（线程池）办理业务，但银行刚开始营业，窗口服务员还未就位（相当于线程池中初始线程数量为0），于是经理（线程池管理者）就安排1号工作人员（创建核心线程1去执行任务）接待A客户。
• 在A客户业务还没办完时，B客户（任务B）又来了，于是经理（线程池管理者）就安排2号工作人员（创建核心线程2去执行任务）接待B客户。
• 在A、B客户都没有办完业务的情况下，C客户（任务C）来了，于是经理（线程池管理者）就安排C客户先坐到等候座位上，并告知他：如果1、2号工作人员空出，C客户就可以前去办理业务。
• 此时D客户（任务D）又来了，（两个窗口都在忙，等候座位也满了）于是经理（线程池管理者）赶紧安排3号工作人员（创建非核心线程3去临时执行任务D）在大堂站着给D客户办理业务。
• 假如前面的业务都没有结束的时候E客户（任务E）又来了，此时2位窗口工作人员，和1位临时工作人员都在忙，等候座位也满了，于是经理只能按《超出银行最大接待能力处理办法》（饱和处理机制）拒接接待E客户。
• 最后，进来办业务的人少了，等候座位也空了，3号工作人员空闲时间也超过了1个小时（线程生存时间），经理就会让这部分空闲的员工人下班（销毁非核心线程），但是为了保证银行正常工作（有一个 allowCoreThreadTimeout 变量控制是否允许销毁核心线程，默认 false），即使窗口工作人员闲着也不得提前下班，所以1、2号工作人员继续等待新客户（池内保持核心线程数量）;

2.3. 拒绝策略

2.3.1. JDK 的4种策略

• AbortPolicy：不处理任务，且抛出 RejectedExecutionException 异常。【默认策略】
• CallerRunsPolicy：不处理任务，交给调用者所在的线程（如主线程）来执行任务。
• DiscardPolicy：不处理任务，且不抛出任何异常。
• DiscardOldestPolicy：LRU 策略，丢弃队列里最近最久不使用的一个任务，并执行当前任务。

2.3.2. 其他策略

• Dubbo 的实现，在抛出 RejectedExecutionException 异常之前会记录日志，并 dump 线程栈信息，方便定位问题。
• Netty 的实现，是创建一个新线程来执行任务。
• ActiveMQ 的实现，带超时等待(60s) 尝试放入队列，类似我们之前自定义的拒绝策略。
• PinPoint 的实现，它使用了一个拒绝策略链，会逐一尝试策略链中每种拒绝策略。

2.4. Executors 工厂

2.4.1. newFixedThreadPool()

创建一个固定线程数的线程池。适用于任务量小且任务相对耗时的场景。

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

【特点】

• 核心线程数 = 最大线程数（没有非核心线程），无超时时间。
• 阻塞队列是无界的，可以放任意数量的任务。

2.4.2. newCachedThreadPool()

创建一个无限线程数的线程池。适用于任务量大且任务相对轻松的场景。

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

【特点】

• 核心线程数是0，最大线程数是 Integer.MAX_ VALUE，非核心线程的空闲生存时间是60s，意味着
  • 全部都是非核心线程（60s 后可以回收）。
  • 非核心线程可以无限创建。
• 队列采用了 SynchronousQueue 实现，特点是没有容量，没有线程来取是放不进去的（一手交钱、一手交货）。

2.4.3. newSingleThreadExecutor()

创建一个单线程的线程池。适用于任务串行且任务相对轻松的场景。

public static ExecutorService newSingleThreadExecutor() {
    // 装饰器模式，防止外部直接调用ThreadPoolExecutor的方法
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()));
}
复制代码

【特点】

• 线程数固定为1，任务数多于1时，会放入无界队列排队。任务执行完毕，这唯一的线程也不会被释放。

【区别】

• 自己创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施；而线程池还会新建一个线程，保证池的正常工作。
• Executors.newSingleThreadExecutor() 线程个数始终为1且不能修改，FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了ExecutorService 接口，因此不能调用 ThreadPoolExecutor 中特有的方法。
• Executors.newFixedThreadPool(1) 初始时为1，以后还可以修改。对外暴露的是 ThreadPoolExecutor 对象，可以强转后调用 setCorePoolSize 等方法进行修改。

2.5. 提交任务

2.5.1. execute()

提交一个不需要返回值的任务，所以无法判断任务是否被线程池执行成功。

ExecutorService threadPool = Executors.newFixedThreadPool(2);
threadPool.execute(() -> System.out.println("执行任务"));
复制代码

【源码分析】

public void execute(Runnable command) {
    if (command == null) throw new NullPointerException();
    int c = ctl.get();
    // workerCountOf(c)会获取当前正在运行的worker数量
    if (workerCountOf(c) < corePoolSize) {
        // 如果workerCount小于corePoolSize，就创建一个worker然后直接执行该任务
        if (addWorker(command, true)) return;
        c = ctl.get();
    }
    // isRunning(c)是判断线程池是否在运行中，如果线程池被关闭了就不会再接受任务
    // workQueue.offer(command)是将任务加入到队列中
    if (isRunning(c) && workQueue.offer(command)) {
        // 如果添加到队列成功了，会再检查一次线程池的状态
        int recheck = ctl.get();
        // 如果线程池关闭了，就将刚才添加的任务从队列中移除
        if (! isRunning(recheck) && remove(command))
            // 执行拒绝策略
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 如果加入队列失败，就尝试直接创建worker来执行任务
    else if (!addWorker(command, false))
        // 如果创建worker失败，就执行拒绝策略
        reject(command);
}
复制代码

2.5.2. submit()

提交一个需要返回值的任务。

ExecutorService threadPool = Executors.newFixedThreadPool(2);
Future<String> future = threadPool.submit(() -> {
    System.out.println("执行任务");
    return "OK";
});
try {
    Thread.sleep(100);
    System.out.println(future.get());	// OK
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}
复制代码

2.5.3. InvokeAll()

批量提交需要返回值的任务。

ExecutorService threadPool = Executors.newFixedThreadPool(2);
List<Future<String>> futures = threadPool.invokeAll(Arrays.asList(
        () -> {
            System.out.println("执行任务1");
            return "OK1";
        },
        () -> {
            System.out.println("执行任务2");
            return "OK2";
        }
));
Thread.sleep(100);
for (Future<String> future : futures) {
    try {
        System.out.println(future.get());
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
}
复制代码

2.5.4. InvokeAny()

批量提交需要返回值的任务。哪个任务先成功执行完毕，返回此任务执行结果，然后取消其它任务。

ExecutorService threadPool = Executors.newFixedThreadPool(2);
String future = threadPool.invokeAny(Arrays.asList(
        () -> {
            System.out.println("执行任务1");
            return "OK1";
        },
        () -> {
            System.out.println("执行任务2");
            return "OK2";
        }
));
Thread.sleep(100);
System.out.println(future);		// OK1 或者 OK2
复制代码

2.6. 关闭线程池

2.6.1. shutdown()

不会立即终止线程池，而是要等所有工作队列中的任务都执行完后才终止，但也不会再接受新的任务。

ExecutorService threadPool = Executors.newFixedThreadPool(2);
threadPool.shutdown();
复制代码

【源码分析】

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 把线程池的状态置为 SHUTDOWN
        advanceRunState(SHUTDOWN);
        // 中断空闲线程
        interruptIdleWorkers();
        // ScheduledThreadPoolExecutor用来hook的地方
        onShutdown();
    } finally {
        mainLock.unlock();
    }
    // 尝试终结线程池（没有运行的线程可以立刻终结，如果还有运行的线程也不会等）
    tryTerminate();
}
复制代码

2.6.2. shutdownNow()

先将线程池的状态设置成 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表。

ExecutorService threadPool = Executors.newFixedThreadPool(2);
threadPool.shutdownNow();
复制代码

【源码分析】

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 把线程池的状态置为 STOP
        advanceRunState(STOP);
        // 中断全部线程
        interruptWorkers();
        // 获取队列中的剩余任务
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    // 尝试终结线程池（没有运行的线程，因此立刻终结）
    tryTerminate();
    return tasks;
}
复制代码

2.7. 任务调度线程池

2.7.1. Timer

Timer 简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，前一个任务的延迟或异常都将会影响到之后的任务。

public static void main(String[] args) {
    Timer timer = new Timer();
    TimerTask task1 = new TimerTask() {
        @Override
        public void run() {
            Log.println("task1");
            Thread.sleep(1000);
        }
    };
    TimerTask task2 = new TimerTask() {
        @Override
        public void run() {
            Log.println("task2");
            Thread.sleep(1000);
        }
    };
    timer.schedule(task1, 0);
    timer.schedule(task2, 0);	// 任务2要等待任务1执行完毕才能执行
}
复制代码

2.7.2. ScheduledThreadPoolExecutor

• schedule()：添加延时任务。
• scheduleAtFixedRate()：添加固定速率的循环延时任务（上一个任务未结束，当前任务也是按时执行）。
• scheduleWithFixedDelay()：添加固定延时的循环延时任务（等待上一个任务结束，再等待延时时间后才执行当前任务）。

2.8. 线程池的异常处理

2.8.1. try/catch

public static void main(String[] args) {
    ExecutorService threadPool = Executors.newFixedThreadPool(1);
    threadPool.submit(() -> {
        Log.println("running...");
        // 自行捕获异常
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            e.printStackTrace();
        }
    });
}
复制代码

15:32:08:572: running...

java.lang.ArithmeticException: / by zero

2.8.2. FutureTask

public static void main(String[] args) throws ExecutionException, InterruptedException {
    ExecutorService threadPool = Executors.newFixedThreadPool(1);
    Future<String> future = threadPool.submit(() -> {
        Log.println("running...");
        int i = 1 / 0;
        return "OK";
    });
    // 如果FutureTask执行成功，则get()获取到返回值，如果执行失败，则抛出异常
    Log.println(future.get());
}
复制代码

15:35:12:300: running...

Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero

需要资料的小伙伴，点赞加收藏，关注我之后添加小助理vx：bjmsb0606006 即可获取免费下载方式