正睿动态
评测室
技术文章
行业资讯
解决方案
安装教程

10分钟手写Java线程池

间隙填充
正睿科技  发布时间：2024-08-30 15:51:33  浏览数：374

关于正睿.png

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


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

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

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

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

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

1725004045038050124.png

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线程池的核心工作流程如下图所示。

1725004050444079068.png

手撸Java线程池

我们自己手动实现的线程池要比Java自身的线程池简单的多，我们去掉了各种复杂的处理方式，只保留了最核心的原理：线程池的使用者向任务队列中添加任务，而线程池本身从任务队列中消费任务并执行任务。

1725004058128027970.png

只要理解了这个核心原理，接下来的代码就简单多了。在实现这个简单的线程池时，我们可以将整个实现过程进行拆解。拆解后的实现流程为：定义核心字段、创建内部类WorkThread、创建ThreadPool类的构造方法和创建执行任务的方法。

1725004111879007398.png

定义核心字段

首先，我们创建一个名称为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 ThreadPool
Thread-9--->> Hello ThreadPool
Thread-5--->> Hello ThreadPool
Thread-8--->> Hello ThreadPool
Thread-4--->> Hello ThreadPool
Thread-1--->> Hello ThreadPool
Thread-2--->> Hello ThreadPool
Thread-5--->> Hello ThreadPool
Thread-9--->> Hello ThreadPool
Thread-0--->> Hello ThreadPool

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

总结

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

疑问没解决? 我们帮您！

如果您在本文中未能找到解决当前疑问的办法，不用担心——正睿专业技术支持团队随时待命

服务项目.png

获取更多帮助

文章来源：华为开发者社区 作者：冰河



关于正睿
公司介绍 新闻中心 工作机会 活动 产品手册
正睿合作伙伴
成为合作伙伴 成为经销商 合作伙伴产品库
法律
隐私政策 网站使用条款 条款和条件
社区
社区 阅读我们的博客 技术支持论坛 授权证书查询
首页|注册|网站地图|通告|联系我们 CopyRight(C)2004-2024 Chongqing Zhengrui Technology Co.,Ltd. All rights reserved. 重庆正睿科技有限公司(C)版权所有 未经书面授权 不得转载、复制或建立镜像 渝ICP备11002339号-1渝公网安备 50010702500475号