10分钟手撸Java线程池,yyds!!

开发 后端
那今天,我们就一起花10分钟手撸一个极简版的Java线程池,让小伙伴们更好的理解线程池的核心原理。

[[428225]]

最近有不少小伙伴私信我说:看了我在【精通高并发系列】文章中写的深度解析线程池源码部分的文章,但是还是有些不明白线程池的实现原理。问我能不能手写一个简单的线程池,帮助读者深刻理解线程池的原理。

这不,我熬夜肝了这篇文章。

在【精通高并发系列】的文章中,我们曾经深度解析过线程池的源码,从源码层面深度解析了线程池的实现原理。

其实,源码是原理落地的最直接体现,看懂源码对于深刻理解原理有着很大的帮助。但是不少小伙伴看源码时,总觉得源码太枯燥了,看不懂。

那今天,我们就一起花10分钟手撸一个极简版的Java线程池,让小伙伴们更好的理解线程池的核心原理。

本文的整体结构如下所示。

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. //模拟实际的线程池使用阻塞队列来实现生产者-消费者模式 
  5. private BlockingQueue<Runnable> workQueue; 
  6.  
  7. //模拟实际的线程池使用List集合保存线程池内部的工作线程 
  8. 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.     } 

创建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)); 

创建执行任务的方法

在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.     } 

完整源码

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

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

没错,我们仅仅用了几十行Java代码就实现了一个极简版的Java线程池,没错,这个极简版的Java线程池的代码却体现了Java线程池的核心原理。

接下来,我们测试下这个极简版的Java线程池。

编写测试程序

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

整体测试代码如下所示。

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

接下来,运行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线程池就开发完成了。

总结

线程池的核心原理其实并不复杂,只要我们耐心的分析,深入其源码理解线程池的核心本质,你就会发现线程池的设计原来是如此的优雅。希望通过这个手写线程池的小例子,能够让你更好的理解线程池的核心原理。

本文转载自微信公众号「冰河技术」,可以通过以下二维码关注。转载本文请联系冰河技术公众号。

 

责任编辑:武晓燕 来源: 冰河技术
相关推荐

2021-05-31 07:22:46

ORM框架程序

2020-02-17 13:45:27

抓取代码工具

2020-10-29 08:28:42

Java NIO异步非阻塞

2023-12-27 08:15:47

Java虚拟线程

2021-10-27 06:49:34

线程池Core函数

2021-07-15 06:43:11

Bash调试脚本

2013-09-13 14:08:01

2021-04-23 09:50:41

topLinux命令

2020-10-13 18:22:58

DevOps工具开发

2014-08-08 09:30:04

android scrollview

2018-06-26 05:23:19

线程安全函数代码

2021-08-01 21:38:07

网页点灯网关

2018-11-28 11:20:53

Python函数式编程编程语言

2022-08-29 15:02:53

远程桌面

2020-08-25 07:47:03

Java并发队列

2021-05-28 07:38:20

内存溢出场景

2021-05-17 20:13:50

数仓操作型数据库

2019-07-18 16:32:06

Python函数数据

2017-02-22 14:46:04

Leader-Foll线程

2018-02-01 14:15:00

Python函数
点赞
收藏

51CTO技术栈公众号