10分钟带你徒手做个Java线程池

摘要：花10分钟开发一个极简版的Java线程池，让小伙伴们更好的理解线程池的核心原理。

本文分享自华为云社区《放大招了，冰河带你10分钟手撸Java线程池，yyds，赶快收藏吧》，作者：冰 河。
Java线程池核心原理

看过Java线程池源码的小伙伴都知道，在Java线程池中最核心的类就是ThreadPoolExecutor，而在ThreadPoolExecutor类中最核心的构造方法就是带有7个参数的构造方法，如下所示。

1. public ThreadPoolExecutor(int corePoolSize,
2. int maximumPoolSize,
3. long keepAliveTime,
4. TimeUnit unit,
5. BlockingQueue<Runnable> workQueue,
6. ThreadFactory threadFactory,
7. 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集合保存线程池内部的工作线程。
  

核心代码如下所示。

1. //默认阻塞队列大小
2. private static final int DEFAULT_WORKQUEUE_SIZE = 5;
3. //模拟实际的线程池使用阻塞队列来实现生产者-消费者模式
4. private BlockingQueue<Runnable> workQueue;
5. //模拟实际的线程池使用List集合保存线程池内部的工作线程
6. private List<WorkThread> workThreads = new ArrayList<WorkThread>();

复制代码

创建内部类WordThread

在ThreadPool类中创建一个内部类WorkThread，模拟线程池中的工作线程。主要的作用就是消费workQueue中的任务，并执行任务。由于工作线程需要不断从workQueue中获取任务，所以，这里使用了while(true)循环不断尝试消费队列中的任务。
核心代码如下所示。

1. //内部类WorkThread，模拟线程池中的工作线程
2. //主要的作用就是消费workQueue中的任务，并执行
3. //由于工作线程需要不断从workQueue中获取任务，使用了while(true)循环不断尝试消费队列中的任务
4. class WorkThread extends Thread{
5. @Override
6. public void run() {
7. //不断循环获取队列中的任务
8. while (true){
9. //当没有任务时，会阻塞
10. try {
11. Runnable workTask = workQueue.take();
12. workTask.run();
13. } catch (InterruptedException e) {
14. e.printStackTrace();
15. }
16. }
17. }
18. }

复制代码

创建ThreadPool类的构造方法

这里，我们为ThreadPool类创建两个构造方法，一个构造方法中传入线程池的容量大小和阻塞队列，另一个构造方法中只传入线程池的容量大小。
核心代码如下所示。

1. //在ThreadPool的构造方法中传入线程池的大小和阻塞队列
2. public ThreadPool(int poolSize, BlockingQueue<Runnable> workQueue){
3. this.workQueue = workQueue;
4. //创建poolSize个工作线程并将其加入到workThreads集合中
5. IntStream.range(0, poolSize).forEach((i) -> {
6. WorkThread workThread = new WorkThread();
7. workThread.start();
8. workThreads.add(workThread);
9. });
10. }
11. //在ThreadPool的构造方法中传入线程池的大小
12. public ThreadPool(int poolSize){
13. this(poolSize, new LinkedBlockingQueue<>(DEFAULT_WORKQUEUE_SIZE));
14. }

复制代码

创建执行任务的方法

在ThreadPool类中创建执行任务的方法execute()，execute()方法的实现比较简单，就是将方法接收到的Runnable任务加入到workQueue队列中。
核心代码如下所示。

1. //通过线程池执行任务
2. public void execute(Runnable task){
3. try {
4. workQueue.put(task);
5. } catch (InterruptedException e) {
6. e.printStackTrace();
7. }
8. }

复制代码

完整源码

这里，我们给出手动实现的ThreadPool线程池的完整源代码，如下所示。

1. package io.binghe.thread.pool;
2. import java.util.ArrayList;
3. import java.util.List;
4. import java.util.concurrent.BlockingQueue;
5. import java.util.concurrent.LinkedBlockingQueue;
6. import java.util.stream.IntStream;
7. /**
8. * @author binghe
9. * @version 1.0.0
10. * @description 自定义线程池
11. */
12. public class ThreadPool {
13. //默认阻塞队列大小
14. private static final int DEFAULT_WORKQUEUE_SIZE = 5;
15. //模拟实际的线程池使用阻塞队列来实现生产者-消费者模式
16. private BlockingQueue<Runnable> workQueue;
17. //模拟实际的线程池使用List集合保存线程池内部的工作线程
18. private List<WorkThread> workThreads = new ArrayList<WorkThread>();
19. //在ThreadPool的构造方法中传入线程池的大小和阻塞队列
20. public ThreadPool(int poolSize, BlockingQueue<Runnable> workQueue){
21. this.workQueue = workQueue;
22. //创建poolSize个工作线程并将其加入到workThreads集合中
23. IntStream.range(0, poolSize).forEach((i) -> {
24. WorkThread workThread = new WorkThread();
25. workThread.start();
26. workThreads.add(workThread);
27. });
28. }
29. //在ThreadPool的构造方法中传入线程池的大小
30. public ThreadPool(int poolSize){
31. this(poolSize, new LinkedBlockingQueue<>(DEFAULT_WORKQUEUE_SIZE));
32. }
33. //通过线程池执行任务
34. public void execute(Runnable task){
35. try {
36. workQueue.put(task);
37. } catch (InterruptedException e) {
38. e.printStackTrace();
39. }
40. }
41. //内部类WorkThread，模拟线程池中的工作线程
42. //主要的作用就是消费workQueue中的任务，并执行
43. //由于工作线程需要不断从workQueue中获取任务，使用了while(true)循环不断尝试消费队列中的任务
44. class WorkThread extends Thread{
45. @Override
46. public void run() {
47. //不断循环获取队列中的任务
48. while (true){
49. //当没有任务时，会阻塞
50. try {
51. Runnable workTask = workQueue.take();
52. workTask.run();
53. } catch (InterruptedException e) {
54. e.printStackTrace();
55. }
56. }
57. }
58. }
59. }

复制代码

没错，我们仅仅用了几十行Java代码就实现了一个极简版的Java线程池，没错，这个极简版的Java线程池的代码却体现了Java线程池的核心原理。
接下来，我们测试下这个极简版的Java线程池。
编写测试程序

测试程序也比较简单，就是通过在main()方法中调用ThreadPool类的构造方法，传入线程池的大小，创建一个ThreadPool类的实例，然后循环10次调用ThreadPool类的execute()方法，向线程池中提交的任务为：打印当前线程的名称--->> Hello ThreadPool。
整体测试代码如下所示。

1. package io.binghe.thread.pool.test;
2. import io.binghe.thread.pool.ThreadPool;
3. import java.util.stream.IntStream;
4. /**
5. * @author binghe
6. * @version 1.0.0
7. * @description 测试自定义线程池
8. */
9. public class ThreadPoolTest {
10. public static void main(String[] args){
11. ThreadPool threadPool = new ThreadPool(10);
12. IntStream.range(0, 10).forEach((i) -> {
13. threadPool.execute(() -> {
14. System.out.println(Thread.currentThread().getName() + "--->> Hello ThreadPool");
15. });
16. });
17. }
18. }

复制代码

接下来，运行ThreadPoolTest类的main()方法，会输出如下信息。

1. Thread-0--->> Hello ThreadPool
2. Thread-9--->> Hello ThreadPool
3. Thread-5--->> Hello ThreadPool
4. Thread-8--->> Hello ThreadPool
5. Thread-4--->> Hello ThreadPool
6. Thread-1--->> Hello ThreadPool
7. Thread-2--->> Hello ThreadPool
8. Thread-5--->> Hello ThreadPool
9. Thread-9--->> Hello ThreadPool
10. Thread-0--->> Hello ThreadPool

复制代码

至此，我们自定义的Java线程池就开发完成了。
总结

线程池的核心原理其实并不复杂，只要我们耐心的分析，深入其源码理解线程池的核心本质，你就会发现线程池的设计原来是如此的优雅。希望通过这个手写线程池的小例子，能够让你更好的理解线程池的核心原理。
 
点击关注，第一时间了解华为云新鲜技术~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！