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

打印 上一主题 下一主题

主题 865|帖子 865|积分 2595

摘要:花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线程池就开发完成了。
总结

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

免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!
回复

使用道具 举报

0 个回复

倒序浏览

快速回复

您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

写过一篇

金牌会员
这个人很懒什么都没写!

标签云

快速回复 返回顶部 返回列表