35.Java线程池（线程池概述、线程池的架构、线程池的种类与创建、线程池的底层原理、线程池的工作流程、线程池的拒绝策略、自定义线程池）

发布于：2025-04-13 ⋅ 阅读:(26) ⋅ 点赞:(0)

一、线程池概述

1、线程池的优势

  • 线程池是一种线程使用模式，线程过多会带来调度开销，进而影响缓存局部性和整体性能，而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务，这避免了在处理短时间任务时创建与销毁线程的代价，线程池不仅能够保证内核的充分利用，还能防止过分调度

  • 线程池的工作主要是控制运行的线程数量，在处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行

2、线程池的特点

  • 降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗

  • 提高响应速度: 当任务到达时，任务可以不需要等待线程创建就能立即执行

  • 提高线程的可管理性: 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

二、线程池的架构

  • Java 中的线程池是通过 Executor 框架实现的，该框架中用到了 Executor 接口，Executors 类，ExecutorService 类，ThreadPoolExecutor 类

三、线程池的种类与创建

1、一池 N 线程
（1）基本介绍

  • 线程池中的线程处于一定的量，可以很好的控制线程的并发量

  • 线程可以重复被使用，在显示关闭之前，都将一直存在

  • 超出一定量的线程被提交时候需在队列中等待

（2）创建方式
ExecutorService threadPool = Executors.newFixedThreadPool(5);
（3）适用场景
  • 适用于可以预测线程数量的业务，或者服务器负载较重，对线程数有严格限制的场景
（4）基本使用
  • 使用 5 个窗口处理 10 个顾客请求
ExecutorService threadPool = Executors.newFixedThreadPool(5);

try {
    for (int i = 1; i <= 10; i++) {

        // 执行线程
        threadPool.execute(() -> {
            System.out.println(Thread.currentThread().getName()+" 办理业务");
        });
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {

    // 关闭线程
    threadPool.shutdown();
}
  • 结果
pool-1-thread-1 办理业务
pool-1-thread-5 办理业务
pool-1-thread-4 办理业务
pool-1-thread-3 办理业务
pool-1-thread-2 办理业务
pool-1-thread-3 办理业务
pool-1-thread-4 办理业务
pool-1-thread-5 办理业务
pool-1-thread-1 办理业务
pool-1-thread-2 办理业务
2、一池一线程
（1）基本介绍
  • 线程池中最多执行一个线程，之后提交的线程活动将会排在队列中依次执行
（2）创建方式
ExecutorService threadPool = Executors.newSingleThreadExecutor();
（3）适用场景
  • 适用于需要保证顺序执行各个任务，并且在任意时间点，不会同时有多个线程的场景
（4）基本使用
  • 使用 1 个窗口处理 10 个顾客请求
ExecutorService threadPool = Executors.newSingleThreadExecutor();

try {
    for (int i = 1; i <= 10; i++) {

        // 执行线程
        threadPool.execute(() -> {
            System.out.println(Thread.currentThread().getName()+" 办理业务");
        });
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {

    // 关闭线程
    threadPool.shutdown();
}
  • 结果
pool-1-thread-1 办理业务
pool-1-thread-1 办理业务
pool-1-thread-1 办理业务
pool-1-thread-1 办理业务
pool-1-thread-1 办理业务
pool-1-thread-1 办理业务
pool-1-thread-1 办理业务
pool-1-thread-1 办理业务
pool-1-thread-1 办理业务
pool-1-thread-1 办理业务
3、一池可扩容线程
（1）基本介绍

  • 线程池中数量没有固定，可达到最大值为 Interger. MAX_VALUE

  • 线程池中的线程可进行缓存重复利用和回收，默认回收时间为一分钟

  • 当线程池中没有可用线程时，会重新创建一个线程

（2）创建方式
ExecutorService threadPool = Executors.newCachedThreadPool();
（3）适用场景
  • 适用于创建一个可无限扩大的线程池，服务器负载压力较轻，执行时间较短，任务多的场景
（4）基本使用
  • 处理 20 个顾客请求
ExecutorService threadPool = Executors.newCachedThreadPool();

try {
    for (int i = 1; i <= 20; i++) {

        // 执行线程
        threadPool.execute(() -> {
            System.out.println(Thread.currentThread().getName()+" 办理业务");
        });
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {

    // 关闭线程
    threadPool.shutdown();
}
  • 结果
pool-1-thread-1 办理业务
pool-1-thread-4 办理业务
pool-1-thread-3 办理业务
pool-1-thread-2 办理业务
pool-1-thread-6 办理业务
pool-1-thread-5 办理业务
pool-1-thread-8 办理业务
pool-1-thread-7 办理业务
pool-1-thread-3 办理业务
pool-1-thread-4 办理业务
pool-1-thread-7 办理业务
pool-1-thread-5 办理业务
pool-1-thread-1 办理业务
pool-1-thread-2 办理业务
pool-1-thread-6 办理业务
pool-1-thread-8 办理业务
pool-1-thread-3 办理业务
pool-1-thread-9 办理业务
pool-1-thread-7 办理业务
pool-1-thread-5 办理业务

四、线程池的底层原理

1、ThreadPoolExecutor 类
  • 通过查看上面三种方式创建线程池对象的源代码，发现都有 new 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.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;
}
2、ThreadPoolExecutor 构造器涉及的七个参数

  1. int corePoolSize：常驻线程数量

  2. int maximumPoolSize：最大线程数量

  3. long keepAliveTime：空闲线程存活时间

  4. TimeUnit unit：空闲线程存时间单位

  5. BlockingQueue workQueue：阻塞队列，存放提交但未执行任务

  6. ThreadFactory threadFactory：线程工厂，用于创建线程（可省略）

  7. RejectedExecutionHandler handler：阻塞队列满时的拒绝策略（可省略）

五、线程池的工作流程

  • 在创建了线程池后，线程池中的线程数为零

  • 当调用 execute 方法添加一个请求任务时，线程池会做如下判断

    1. 如果正在运行的线程数量小于 corePool 的线程数量，那么马上创建线程运行这个任务

    2. 如果正在运行的线程数量大于或等于 corePool 的线程数量，那么将这个任务存入阻塞队列

    3. 如果这个时候队列已满且正在运行的线程数量小于 maximumPool 的线程数量，则创建非核心线程立刻运行这个任务

    4. 如果队列已满且正在运行的线程数量大于或等于 maximumPool 的线程数量，那么线程池会启动拒绝策略

  • 当一个线程完成任务时，它会从队列中取下一个任务来执行

  • 当一个线程空闲超过一定的时间时，会做如下判断

    1. 如果当前运行的线程数大于 corePool 的线程数量，那么这个线程就被停掉

    2. 线程池的所有任务完成后，最终会收缩到 corePool 的大小

六、线程池的拒绝策略

1、 AbortPolicy
  • 默认的拒绝策略，会直接抛出 RejectedExecutionException 异常阻止系统正常运行
2、DiscardPolicy
  • 该策略会丢弃无法处理的任务，不给予任何处理也不抛出异常，如果允许任务丢失，这是最好的一种策略
3、DiscardOldestPolicy
  • 丢弃队列中等待最久的任务，然后把当前任务存入队列中，并尝试提交当前任务
4、CallerRunsPolicy
  • 该策略既不会丢弃任务，也不会抛出异常，而是将任务退回给调用者

七、自定义线程池

1、Executors 返回的线程池对象的弊端

  • FixedThreadPool 和 SingleThreadExecutor 允许请求队列的长度为 Interger.MAX_VALUE，可能会堆积大量异常， 从而导致 OOM

  • CachedThreadPool 允许的创建线程数量为 Interger.MAX_VALUE，可能会创建大量线程，从而导致 OOM

2、具体实现
package com.my.pool;

import java.util.concurrent.*;

public class MyThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                2L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());

        // 处理 10 个顾客请求
        try {
            for (int i = 1; i <= 10; i++) {

                // 执行线程
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName()+" 办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            // 关闭线程
            threadPool.shutdown();
        }
    }
}
  • 结果
pool-1-thread-1 办理业务
pool-1-thread-4 办理业务
pool-1-thread-3 办理业务
pool-1-thread-2 办理业务
pool-1-thread-3 办理业务
pool-1-thread-4 办理业务
pool-1-thread-1 办理业务
pool-1-thread-5 办理业务

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布