本文分享自华为云社区《放大招了，冰河带你10分钟手撸Java线程池，yyds，赶快收藏吧》，作者：冰 河。
Java 线程池核心原理
看过 Java 线程池源码的小伙伴都知道，在 Java 线程池中最核心的类就是 ThreadPoolExecutor，而在 ThreadPoolExecutor 类中最核心的构造方法就是带有 7 个参数的构造方法，如下所示。
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
复制代码
各参数的含义如下所示。
corePoolSize：线程池中的常驻核心线程数。
maximumPoolSize：线程池能够容纳同时执行的最大线程数，此值大于等于 1。
keepAliveTime：多余的空闲线程存活时间，当空间时间达到 keepAliveTime 值时，多余的线程会被销毁直到只剩下 corePoolSize 个线程为止。
unit：keepAliveTime 的单位。
workQueue：任务队列，被提交但尚未被执行的任务。
threadFactory：表示生成线程池中工作线程的线程工厂，用户创建新线程，一般用默认即可。
handler：拒绝策略，表示当线程队列满了并且工作线程大于等于线程池的最大显示数(maxnumPoolSize)时，如何来拒绝请求执行的 runnable 的策略。
并且 Java 的线程池是通过 生产者-消费者模式 实现的，线程池的使用方是生产者，而线程池本身就是消费者。
Java 线程池的核心工作流程如下图所示。
手撸 Java 线程池
我们自己手动实现的线程池要比 Java 自身的线程池简单的多，我们去掉了各种复杂的处理方式，只保留了最核心的原理：线程池的使用者向任务队列中添加任务，而线程池本身从任务队列中消费任务并执行任务。
只要理解了这个核心原理，接下来的代码就简单多了。在实现这个简单的线程池时，我们可以将整个实现过程进行拆解。拆解后的实现流程为：定义核心字段、创建内部类 WorkThread、创建 ThreadPool 类的构造方法和创建执行任务的方法。
定义核心字段
首先，我们创建一个名称为 ThreadPool 的 Java 类，并在这个类中定义如下核心字段。
DEFAULT_WORKQUEUE_SIZE：静态常量，表示默认的阻塞队列大小。
workQueue：模拟实际的线程池使用阻塞队列来实现生产者-消费者模式。
workThreads：模拟实际的线程池使用 List 集合保存线程池内部的工作线程。
核心代码如下所示。
//默认阻塞队列大小private static final int DEFAULT_WORKQUEUE_SIZE = 5;
//模拟实际的线程池使用阻塞队列来实现生产者-消费者模式private BlockingQueue<Runnable> workQueue;
//模拟实际的线程池使用List集合保存线程池内部的工作线程private List<WorkThread> workThreads = new ArrayList<WorkThread>();
复制代码
创建内部类 WordThread
在 ThreadPool 类中创建一个内部类 WorkThread，模拟线程池中的工作线程。主要的作用就是消费 workQueue 中的任务，并执行任务。由于工作线程需要不断从 workQueue 中获取任务，所以，这里使用了 while(true)循环不断尝试消费队列中的任务。
核心代码如下所示。
//内部类WorkThread，模拟线程池中的工作线程//主要的作用就是消费workQueue中的任务，并执行//由于工作线程需要不断从workQueue中获取任务，使用了while(true)循环不断尝试消费队列中的任务class WorkThread extends Thread{ @Override public void run() { //不断循环获取队列中的任务 while (true){ //当没有任务时，会阻塞 try { Runnable workTask = workQueue.take(); workTask.run(); } catch (InterruptedException e) { e.printStackTrace(); } } }}
复制代码
创建 ThreadPool 类的构造方法
这里，我们为 ThreadPool 类创建两个构造方法，一个构造方法中传入线程池的容量大小和阻塞队列，另一个构造方法中只传入线程池的容量大小。
核心代码如下所示。
//在ThreadPool的构造方法中传入线程池的大小和阻塞队列public ThreadPool(int poolSize, BlockingQueue<Runnable> workQueue){ this.workQueue = workQueue; //创建poolSize个工作线程并将其加入到workThreads集合中 IntStream.range(0, poolSize).forEach((i) -> { WorkThread workThread = new WorkThread(); workThread.start(); workThreads.add(workThread); });}
//在ThreadPool的构造方法中传入线程池的大小public ThreadPool(int poolSize){ this(poolSize, new LinkedBlockingQueue<>(DEFAULT_WORKQUEUE_SIZE));}
复制代码
创建执行任务的方法
在 ThreadPool 类中创建执行任务的方法 execute()，execute()方法的实现比较简单，就是将方法接收到的 Runnable 任务加入到 workQueue 队列中。
核心代码如下所示。
//通过线程池执行任务public void execute(Runnable task){ try { workQueue.put(task); } catch (InterruptedException e) { e.printStackTrace(); }}
复制代码
完整源码
这里，我们给出手动实现的 ThreadPool 线程池的完整源代码，如下所示。
package io.binghe.thread.pool;
import java.util.ArrayList;import java.util.List;import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;import java.util.stream.IntStream;
/** * @author binghe * @version 1.0.0 * @description 自定义线程池 */public class ThreadPool {
//默认阻塞队列大小 private static final int DEFAULT_WORKQUEUE_SIZE = 5;
//模拟实际的线程池使用阻塞队列来实现生产者-消费者模式 private BlockingQueue<Runnable> workQueue;
//模拟实际的线程池使用List集合保存线程池内部的工作线程 private List<WorkThread> workThreads = new ArrayList<WorkThread>();
//在ThreadPool的构造方法中传入线程池的大小和阻塞队列 public ThreadPool(int poolSize, BlockingQueue<Runnable> workQueue){ this.workQueue = workQueue; //创建poolSize个工作线程并将其加入到workThreads集合中 IntStream.range(0, poolSize).forEach((i) -> { WorkThread workThread = new WorkThread(); workThread.start(); workThreads.add(workThread); }); }
//在ThreadPool的构造方法中传入线程池的大小 public ThreadPool(int poolSize){ this(poolSize, new LinkedBlockingQueue<>(DEFAULT_WORKQUEUE_SIZE)); }
//通过线程池执行任务 public void execute(Runnable task){ try { workQueue.put(task); } catch (InterruptedException e) { e.printStackTrace(); } }
//内部类WorkThread，模拟线程池中的工作线程 //主要的作用就是消费workQueue中的任务，并执行 //由于工作线程需要不断从workQueue中获取任务，使用了while(true)循环不断尝试消费队列中的任务 class WorkThread extends Thread{ @Override public void run() { //不断循环获取队列中的任务 while (true){ //当没有任务时，会阻塞 try { Runnable workTask = workQueue.take(); workTask.run(); } catch (InterruptedException e) { e.printStackTrace(); } } } }}
复制代码
没错，我们仅仅用了几十行 Java 代码就实现了一个极简版的 Java 线程池，没错，这个极简版的 Java 线程池的代码却体现了 Java 线程池的核心原理。
接下来，我们测试下这个极简版的 Java 线程池。
编写测试程序
测试程序也比较简单，就是通过在 main()方法中调用 ThreadPool 类的构造方法，传入线程池的大小，创建一个 ThreadPool 类的实例，然后循环 10 次调用 ThreadPool 类的 execute()方法，向线程池中提交的任务为：打印当前线程的名称--->> Hello ThreadPool。
整体测试代码如下所示。
package io.binghe.thread.pool.test;
import io.binghe.thread.pool.ThreadPool;
import java.util.stream.IntStream;
/** * @author binghe * @version 1.0.0 * @description 测试自定义线程池 */public class ThreadPoolTest {
public static void main(String[] args){ ThreadPool threadPool = new ThreadPool(10); IntStream.range(0, 10).forEach((i) -> { threadPool.execute(() -> { System.out.println(Thread.currentThread().getName() + "--->> Hello ThreadPool"); }); }); }}
复制代码
接下来，运行 ThreadPoolTest 类的 main()方法，会输出如下信息。
Thread-0--->> Hello ThreadPoolThread-9--->> Hello ThreadPoolThread-5--->> Hello ThreadPoolThread-8--->> Hello ThreadPoolThread-4--->> Hello ThreadPoolThread-1--->> Hello ThreadPoolThread-2--->> Hello ThreadPoolThread-5--->> Hello ThreadPoolThread-9--->> Hello ThreadPoolThread-0--->> Hello ThreadPool
复制代码
至此，我们自定义的 Java 线程池就开发完成了。
总结
线程池的核心原理其实并不复杂，只要我们耐心的分析，深入其源码理解线程池的核心本质，你就会发现线程池的设计原来是如此的优雅。希望通过这个手写线程池的小例子，能够让你更好的理解线程池的核心原理。
点击关注，第一时间了解华为云新鲜技术~
评论