10分钟手撸Java线程池，yyds！！

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

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

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

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

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

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

Java线程池核心原理

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

 
 
 
 
      
  
  
  
  1. public ThreadPoolExecutor(int corePoolSize, 
    2.   
  
  
  
  2.                              int maximumPoolSize, 
    3.   
  
  
  
  3.                              long keepAliveTime, 
    4.   
  
  
  
  4.                              TimeUnit unit, 
    5.   
  
  
  
  5.                              BlockingQueue workQueue, 
    6.   
  
  
  
  6.                              ThreadFactory threadFactory, 
    7.   
  
  
  
  7.                              RejectedExecutionHandler handler) 
    8.

各参数的含义如下所示。

  • 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.   
  
  
  
  2. private static final int DEFAULT_WORKQUEUE_SIZE = 5; 
    3.   
  
  
  
  3.  
    4.   
  
  
  
  4. //模拟实际的线程池使用阻塞队列来实现生产者-消费者模式 
    5.   
  
  
  
  5. private BlockingQueue workQueue; 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. //模拟实际的线程池使用List集合保存线程池内部的工作线程 
    8.   
  
  
  
  8. private List workThreads = new ArrayList(); 
    9.

创建内部类WordThread

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

核心代码如下所示。

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

创建ThreadPool类的构造方法

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

核心代码如下所示。

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

创建执行任务的方法

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

核心代码如下所示。

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

完整源码

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

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

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

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

编写测试程序

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

整体测试代码如下所示。

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

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

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

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

总结

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

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

本文标题：10分钟手撸Java线程池，yyds！！
转载源于：http://www.csdahua.cn/qtweb/news14/471864.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

定制网站知识

分类信息网

成都富士康招工　　 　高端网站建设　　 　服务器租凭　　 　成都网站建设　　 　企业网站维护　　 　简阳网站制作　　 　二枢服务器托管　　 　成都免费做网站公司　　 　营销型网站建设　　 　域名ssl证书　　 　成都网站营销　　 　名片印刷厂　　 　宏鑫宇康　　 　响应式网站建设　　 　企业邮箱　　 　全网营销网站推广　　 　小谭网创广告　　 　邛崃柴油发电机维修保养公司　　 　成都小程序开发公司　　 　平武做网站