线程池

马小玲
72 阅读11分钟

线程池七大核心参数以及创建线程池的方式

ThreadPoolExecutor的继承关系

image-20230315105121944.png

线程池的优势：

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

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

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

线程池的构造函数

public ThreadPoolExecutor(int corePoolSize,      //核心线程数
                              int maximumPoolSize, //线程池所能容纳的最大线程数
                              long keepAliveTime, //线程闲置超时时间（非核心线程）
                              TimeUnit unit,  //指定 keepAliveTime 参数的时间单位
                              BlockingQueue<Runnable> workQueue) {//在任务执行前用于保存任务的队列。这个队列将只保存由execute方法提交的Runnable任务
    
        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;
}

关线程池构造函数7个参数：

corePoolSize 线程池核心线程大小（必需）

线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。任务提交到线程池后，首先会检查当前线程数是否达到了corePoolSize，如果没有达到的话，则会创建一个新线程来处理这个任务。

maximumPoolSize 线程池最大线程数量（必需）

当前线程数达到corePoolSize后，如果继续有任务被提交到线程池，会将任务缓存到工作队列中。如果队列也已满，则会去创建一个新线程来出来这个处理。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize指定。

keepAliveTime 空闲线程存活时间（必需）

一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定

unit 空闲线程存活时间单位（必需）

  • TimeUnit.MILLISECONDS【毫秒】
  • TimeUnit.SECONDS【秒】
  • TimeUnit.MINUTES【分】。

workQueue 工作队列 (必需)

新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：

①ArrayBlockingQueue

基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。

②LinkedBlockingQuene

基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而基本不会去创建新线程直到maxPoolSize（很难达到Interger.MAX这个数），因此使用该工作队列时，参数maxPoolSize其实是不起作用的。

③SynchronousQuene

一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。

④PriorityBlockingQueue

具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

threadFactory 线程工厂

创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等

handler 拒绝策略(都是ThreadPollExecutor的内部类)

当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略：

①CallerRunsPolicy

该策略下，在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务

②AbortPolicy （默认的拒绝模式）

该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。

③DiscardPolicy

该策略下，直接丢弃任务，什么都不做。

④DiscardOldestPolicy

该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

线程池的工作原理

watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9qaW1teXN1bi5ibG9nLmNzZG4ubmV0,size_16,color_FFFFFF,t_70.png 临时线程什么时候创建啊?

  • 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

什么时候会开始拒绝任务?

  • 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

线程工厂（threadFactory）

线程工厂指定创建线程的方式，需要实现 ThreadFactory 接口，并实现 newThread(Runnable r) 方法。该参数可以不用指定，Executors 已经为我们实现了一个默认的线程工厂：

public interface ThreadFactory {

    // 构造一个新的Thread 。实现还可以初始化优先级、名称、守护进程状态、 ThreadGroup等
    Thread newThread(Runnable r);
}

默认线程工厂源代码;

/**
 * The default thread factory.
 */
private static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;
 
    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }
 
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

ExecutorService的常用方法:

方法名称说明
execute(Runnable command)执行任务/命令，没有返回值，一般用来执行 Runnable 任务
shutdown()等任务执行完毕后关闭线程池(一般不会关闭线程池)
shutdownNow()立刻关闭，停止正在执行的任务，并返回队列中未执行的任务(一般不会关闭线程池)

功能线程池（Executors 线程池工具类）

嫌上面使用线程池的方法太麻烦？其实Executors已经为我们封装好了 4 种常见的功能线程池，如下：

  • 定长线程池（FixedThreadPool）

  • 定时线程池（ScheduledThreadPool ）

  • 可缓存线程池（CachedThreadPool）

  • 单线程化线程池（SingleThreadExecutor）

    （不建议使用线程池工具类，原因如下：）

    方法名称存在问题
    ExecutorService newFixedThreadPool(int nThreads)允许创建的线程是固定的, 但是线程允许请求的任务队列长度是无穷大的(Integer.MAX_VALUE)，可能出现OOM内存溢出错误（java.lang.OutOfMemoryError ）
    ExecutorService newSingleThreadExecutor()允许创建的线程是固定的, 允许请求的任务队列长度是无穷大的(Integer.MAX_VALUE)，可能出现OOM内存溢出错误（java.lang.OutOfMemoryError ）
    ExecutorService newCachedThreadPool()创建的线程数量最大上限是无穷大(Integer.MAX_VALUE)， 线程数可能会随着任务1:1增长，也可能出现OOM内存溢出错误 ( java.lang.OutOfMemoryError ）
    ScheduledExecutorService newScheduledThreadPool(int corePoolSize)创建的线程数量最大上限是无穷大(Integer.MAX_VALUE)， 线程数可能会随着任务1:1增长，也可能出现OOM内存溢出错误 ( java.lang.OutOfMemoryError ）

定长线程池（FixedThreadPool）

创建方法的源码：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(),
                                  threadFactory);
}
//-----------------------------------------------------------------------------
//示例：
    public static void main(String[] args) {
    // 1. 创建线程池对象
    ExecutorService pool = Executors.newFixedThreadPool(3);
    // 2. 提交Runnable任务到线程池
    pool.execute(new MyRunnable());
    pool.execute(new MyRunnable());
    pool.execute(new MyRunnable());
    // 提交第四个任务就已经没有多余线程了, 会被拒绝
    pool.execute(new MyRunnable());
}
  • 特点：只有核心线程，线程数量固定，执行完立即回收，任务队列为链表结构的有界队列。
  • 应用场景：控制线程最大并发数。

使用示例：

// 1. 创建定长线程池对象 & 设置线程池线程数量固定为3
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run() {
     System.out.println("执行任务啦");
  }
};
// 3. 向线程池提交任务
fixedThreadPool.execute(task);

定时线程池（ScheduledThreadPool ）

创建方法的源码：

private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;
 
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}
 
public static ScheduledExecutorService newScheduledThreadPool(
        int corePoolSize, ThreadFactory threadFactory) {
    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue(), threadFactory);
}
  • 特点：核心线程数量固定，非核心线程数量无限，执行完闲置 10ms 后回收，任务队列为延时阻塞队列。
  • 应用场景：执行定时或周期性的任务。

使用示例：

// 1. 创建 定时线程池对象 & 设置线程池线程数量固定为5
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run() {
     System.out.println("执行任务啦");
  }
};
// 3. 向线程池提交任务
scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟1s后执行任务
scheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);// 延迟10ms后、每隔1000ms执行任务

可缓存线程池（CachedThreadPool）

创建方法的源码：

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(),
                                  threadFactory);
}
  • 特点：无核心线程，非核心线程数量无限，执行完闲置 60s 后回收，任务队列为不存储元素的阻塞队列。
  • 应用场景：执行大量、耗时少的任务。

使用示例：

// 1. 创建可缓存线程池对象
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run() {
     System.out.println("执行任务啦");
  }
};
// 3. 向线程池提交任务
cachedThreadPool.execute(task);

单线程化线程池（SingleThreadExecutor）

创建方法的源码：

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
}
  • 特点：只有 1 个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列。
  • 应用场景：不适合并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作，如数据库操作、文件操作等。

使用示例：

// 1. 创建单线程化线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
  public void run() {
     System.out.println("执行任务啦");
  }
};
// 3. 向线程池提交任务
singleThreadExecutor.execute(task);

对比

类型池内 线程类型池内 线程数量处理特点应用场景
FixedThreadPool （定长线程池）核心线程固定只有核心线程，线程数量固定，执行完立即回收，任务队列为链表结构的有界队列控制线程最大并发数
ScheduleThreadPoll 定时线程池核心&非核心核心线程固定非核心线程 无限制核心线程数量固定，非核心线程数量无限，执行完闲置 10ms 后回收，任务队列为延时阻塞队列执行定时、周期性 任务
CachedThreadPool（可缓存线程池）非核心线程不固定，可无限大无核心线程，非核心线程数量无限，执行完闲置 60s 后回收，任务队列为不存储元素的阻塞队列。执行大量、耗时少的任务
SingleThreadExecutor(单线程化线程池)核心线程1个只有 1 个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列不适合并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作，如数据库操作、文件操作等

线程池代码创建示例：

import java.util.concurrent.*;
public class TreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
                8,  			//核心线程数
                20,            //最大线程数
                60,            //临时线程过期时间
                TimeUnit.MILLISECONDS,//线程过期时间单位
                new ArrayBlockingQueue<>(10), //工作队列，该模式当线程数量达到核心线程数后，会将新任务放到队列尾如果队列满了之后会创建新的线程
                Executors.defaultThreadFactory(),//默认的线程工厂
                new ThreadPoolExecutor.AbortPolicy() //直接丢弃任务并抛出异常
        );
        //实例化自定义线程任务
        Runnable myThread = new MyThread();
        //三个线程任务会被三个核心线程调用执行
        executorService.execute(myThread);
        executorService.execute(myThread);
        executorService.execute(myThread);
    }
}

//自定义线程执行任务
class MyThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("正在执行线程"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

更多文章参考：

为什么有人说Java线程池五种状态，有人说六种？

Happens-before规则理解可见性和有序性（Volatile域是什么？）

阿里P8并发学习路线，啃完这份734页Java并发宝典，阿里入职在望

avatar
文章
阅读
粉丝