JUC--线程池

七、线程池

7.1线程池的概述

1. 定义：线程池是一个容纳多个线程的容器，线程池中的线程可以被重复利用，从而避免了频繁创建和销毁线程带来的性能开销。
2. 线程池的作用：
   • 降低资源消耗：通过线程复用，避免了频繁的线程创建和销毁，提高了资源利用率。
   • 提高响应速度：当任务到达时，如果有空闲线程，则可以立即执行，避免了线程的创建和销毁延迟。
   • 提高线程的可管理性：通过对线程的管理，避免了无限制地创建线程，增强了系统的稳定性和可控性。
3. 核心思想：线程池的核心思想是 线程复用，即通过重复使用现有线程来处理多个任务。

7.2线程池的构建与参数

ThreadPoolExecutor 的构造方法

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)

核心参数

• corePoolSize：核心线程数，即线程池中可以一直保持活动的线程数。
• maximumPoolSize：最大线程数，线程池中允许的最大线程数量。
• keepAliveTime：非核心线程的空闲时间，当线程池中的线程数量超过 corePoolSize 且任务完成时，超过的线程在空闲时会被销毁。
• workQueue：任务队列，用于存放等待执行的任务。
• threadFactory：线程工厂，用于创建新线程。
• handler：拒绝策略，定义了线程池满载时，如何处理新的任务。

拒绝策略（RejectedExecutionHandler）:

• AbortPolicy（默认策略）：抛出 RejectedExecutionException 异常。
• CallerRunsPolicy：将任务回退到调用者的线程来执行。
• DiscardPolicy：直接丢弃任务，不抛出任何异常。
• DiscardOldestPolicy：丢弃队列中最早的任务，尝试执行当前任务。

线程池的工作原理

1.线程池的初始化：线程池创建后不会立刻创建线程，只有在调用 execute() 方法时，线程池才会开始创建线程。

2.任务提交过程：

• 如果运行线程数小于 corePoolSize，立即创建线程并执行任务。
• 如果运行线程数大于或等于 corePoolSize，则将任务放入任务队列。
• 如果队列已满且运行线程数小于 maximumPoolSize，则创建新的非核心线程执行任务。
• 如果队列满且线程数已经达到 maximumPoolSize，则执行拒绝策略。

3.线程空闲回收：当线程空闲超过 keepAliveTime，且线程池中的线程数大于 corePoolSize，空闲线程会被销毁，线程池会收缩到核心线程数的大小。

Executors构造方法

Executors 提供了四种线程池的创建：newCachedThreadPool、newFixedThreadPool、newSingleThreadExecutor、newScheduledThreadPool

newFixedThreadPool

newFixedThreadPool(int nThreads)：创建一个固定大小的线程池，适用于任务量已知且长期运行的场景。所有任务会被放入一个无界队列中，任务执行较慢可能导致内存溢出。

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

特点：

1. 核心线程数 == 最大线程数（没有救济线程被创建），因此无需超时时间

2. LinkedBlockingQueue 是一个单向链表实现的阻塞队列，默认大小为Integer.MAX_VALUE ，也就是无界队列，可以放任意数量的任务，在任务比较多的时候会导致 OOM（内存溢出）

3. 适用于任务量已知，相对耗时的长期任务

newCachedThreadPool

newCachedThreadPool()：创建一个可扩容的线程池，适用于任务量不稳定且每个任务执行时间较短的场景。核心线程数为 0，最大线程数为 Integer.MAX_VALUE，可能会导致大量线程创建和 OOM。

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

特点：

1. 核心线程数是 0， 最大线程数是 29 个 1，全部都是救急线程（60s 后可以回收），可能会创建大量线程，从而导致 OOM
2. SynchronousQueue 作为阻塞队列，没有容量，没有线程来取是放不进去的（类似一手交钱、一手交货）
3. 适合任务数比较密集，但每个任务执行时间较短的情况

newSingleThreadExecutor

newSingleThreadExecutor()：创建一个只有一个线程的线程池，适用于需要顺序执行任务的场景，保证任务按顺序执行。

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

使用场景：

• 保证所有任务按照指定顺序执行，线程数固定为 1，任务数多于 1 时会放入无界队列排队，任务执行完毕，这唯一的线程也不会被释放

newScheduledThreadPool(int corePoolSize)

创建一个可以执行延时任务的线程池，适用于定时任务和延时任务。

区别：

• 创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，线程池会新建一个线程，保证池的正常工作

• Executors.newSingleThreadExecutor() 线程个数始终为 1，不能修改。

  FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了 ExecutorService 接口，因此不能调用 ThreadPoolExecutor 中特有的方法

  原因：父类不能直接调用子类中的方法，需要反射或者创建对象的方式，可以调用子类静态方法

• Executors.newFixedThreadPool(1) 初始时为 1，可以修改。对外暴露的是 ThreadPoolExecutor对象，可以强转后调用 setCorePoolSize 等方法进行修改
  

为什么不推荐使用内置线程池？

《阿里巴巴 Java 开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 构造函数的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

Executors 返回线程池对象的弊端如下：

• FixedThreadPool 和 SingleThreadExecutor:使用的是有界阻塞队列是 LinkedBlockingQueue ，其任务队列的最大长度为 Integer.MAX_VALUE ，可能堆积大量的请求，从而导致 OOM。
• CachedThreadPool:使用的是同步队列 SynchronousQueue, 允许创建的线程数量为 Integer.MAX_VALUE ，如果任务数量过多且执行速度较慢，可能会创建大量的线程，从而导致 OOM。
• ScheduledThreadPool 和 SingleThreadScheduledExecutor :使用的无界的延迟阻塞队列 DelayedWorkQueue ，任务队列最大长度为 Integer.MAX_VALUE ，可能堆积大量的请求，从而导致 OOM。

7.3线程池中线程异常后，销毁还是复用？

execute() 提交任务时的异常处理：

• 如果任务抛出异常，当前线程会终止，线程池会创建新线程来替换。

submit() 提交任务时的异常处理：

• 如果任务抛出异常，异常会被封装在 Future 对象中，继续复用，可以通过 Future.get() 获取异常信息。

7.4如何给线程池命名？

初始化线程池的时候需要显示命名（设置线程池名称前缀），有利于定位问题。

默认情况下创建的线程名字类似 pool-1-thread-n 这样的，没有业务含义，不利于我们定位问题。

给线程池里的线程命名通常有下面两种方式：

1、利用 guava 的 ThreadFactoryBuilder

ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat(threadNamePrefix + "-%d").setDaemon(true).build();
ExecutorService threadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.MINUTES, workQueue, threadFactory);

2、自己实现 ThreadFactory。

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;/*** 线程工厂，它设置线程名称，有利于我们定位问题。*/
public final class NamingThreadFactory implements ThreadFactory {private final AtomicInteger threadNum = new AtomicInteger();private final String name;/*** 创建一个带名字的线程池生产工厂*/public NamingThreadFactory(String name) {this.name = name;}@Overridepublic Thread newThread(Runnable r) {Thread t = new Thread(r);t.setName(name + " [#" + threadNum.incrementAndGet() + "]");return t;}
}