正文

Tomcat修正JDK原生线程池bug的实现原理

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0729

这篇文章主要介绍了Tomcat是如何修正JDK原生线程池bug的，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下

为提高处理能力和并发度，web容器一般会把处理请求的任务放到线程池，而jdk的原生线程池先天适合cpu密集型任务，于是tomcat改造之。

tomcat 线程池原理

其实threadpoolexecutor的参数主要有如下关键点：

限制线程个数

Tomcat修正JDK原生线程池bug的实现原理

限制队列长度

Tomcat修正JDK原生线程池bug的实现原理

而tomcat对这俩资源都需要限制，否则高并发下cpu、内存都有被耗尽可能。
因此tomcat的线程池传参：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 定制的任务队列
taskqueue = new taskqueue(maxqueuesize);
 
// 定制的线程工厂
taskthreadfactory tf = new taskthreadfactory(nameprefix,
                                             daemon,
                                             getthreadpriority()
);
 
// 定制线程池
executor = new threadpoolexecutor(getminsparethreads(),
                                  getmaxthreads(),
                                  maxidletime,
                                  timeunit.milliseconds,
                                  taskqueue,
                                  tf);

tomcat对线程数也有限制，设置：

  • 核心线程数（minsparethreads）
  • 最大线程池数（maxthreads）

tomcat线程池还有自己的特色任务处理流程，通过重写execute方法实现了自己的特色任务处理逻辑：

  1. 前corepoolsize个任务时，来一个任务就创建一个新线程
  2. 再有任务，就把任务放入任务队列，让所有线程去抢。若队列满，就创建临时线程
  3. 总线程数达到maximumpoolsize，则继续尝试把任务放入任务队列
  4. 若缓冲队列也满了，插入失败，执行拒绝策略

和 jdk 线程池的区别就在step3，tomcat在线程总数达到最大数时，不是立即执行拒绝策略，而是再尝试向任务队列添加任务，添加失败后再执行拒绝策略。

具体又是如何实现的呢？

Tomcat修正JDK原生线程池bug的实现原理

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void execute(runnable command, long timeout, timeunit unit) {
    submittedcount.incrementandget();
    try {
        // 调用jdk原生线程池的execute执行任务
        super.execute(command);
    } catch (rejectedexecutionexception rx) {
       // 总线程数达到maximumpoolsize后，jdk原生线程池会执行默认拒绝策略
        if (super.getqueue() instanceof taskqueue) {
            final taskqueue queue = (taskqueue)super.getqueue();
            try {
                // 继续尝试把任务放入任务队列
                if (!queue.force(command, timeout, unit)) {
                    submittedcount.decrementandget();
                    // 若缓冲队列还是满了，插入失败，执行拒绝策略。
                    throw new rejectedexecutionexception("...");
                }
            }
        }
    }
}

定制任务队列

tomcat线程池的execute方法第一行：

?
1
submittedcount.incrementandget();

任务执行失败，抛异常时，将该计数器减一：

?
1
submittedcount.decrementandget();

tomcat线程池使用 submittedcount 变量维护已提交到线程池，但未执行完的任务数量。

为何要维护这样一个变量呢？

tomcat的任务队列taskqueue扩展了jdk的linkedblockingqueue，tomcat给了它一个capacity，传给父类linkedblockingqueue的构造器。

?
1
2
3
4
5
6
7
public class taskqueue extends linkedblockingqueue<runnable> {
 
  public taskqueue(int capacity) {
      super(capacity);
  }
  ...
}

capacity参数通过tomcat的maxqueuesize参数设置，但maxqueuesize默认值integer.max_value：当前线程数达到核心线程数后，再来任务的话线程池会把任务添加到任务队列，并且总会成功，就永远无机会创建新线程了。

为解决该问题，taskqueue重写了linkedblockingqueue#offer，在合适时机返回false，表示任务添加失败，这时线程池就会创建新线程。

什么叫合适时机？

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class taskqueue extends linkedblockingqueue<runnable> {
 
  ...
   @override
  // 线程池调用任务队列的方法时，当前线程数 ＞ core线程数
  public boolean offer(runnable o) {
 
      // 若线程数已达max，则不能创建新线程，只能放入任务队列
      if (parent.getpoolsize() == parent.getmaximumpoolsize())
          return super.offer(o);
          
      // 至此，表明 max线程数 > 当前线程数 ＞ core线程数
      // 说明可创建新线程：
      
      // 1. 若已提交任务数 ＜ 当前线程数
      //    表明还有空闲线程，无需创建新线程
      if (parent.getsubmittedcount()<=(parent.getpoolsize()))
          return super.offer(o);
          
      // 2. 若已提交任务数 ＞ 当前线程数
      //    线程不够用了，返回false去创建新线程
      if (parent.getpoolsize()<parent.getmaximumpoolsize())
          return false;
          
      // 默认情况下总是把任务放入任务队列
      return super.offer(o);
  }
  
}

所以tomcat维护 已提交任务数 是为了在任务队列长度无限时，让线程池还能有机会创建新线程。

到此这篇关于tomcat是如何修正jdk原生线程池bug的的文章就介绍到这了,更多相关tomcat jdk原生线程池内容请搜索米米素材网以前的文章或继续浏览下面的相关文章希望大家以后多多支持米米素材网！

原文链接：https://blog.csdn.net/qq_33589510/article/details/119154878