为什么tomcat要自定义线程池实现？

已于 2023-09-21 20:21:24 修改
阅读量592 收藏 1
点赞数 1
分类专栏： Java基础 多线程 调优 文章标签： tomcat java
于 2023-09-21 19:56:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ethan_199402/article/details/133043129
版权
Java基础 同时被 3 个专栏收录
8 篇文章 0 订阅
订阅专栏
多线程
1 篇文章 0 订阅
订阅专栏
调优
1 篇文章 0 订阅
订阅专栏

背景

最近在研究tomcat调优的问题，开发人员做过的最多的tomcat调优想必就是线程池调优了，但是tomcat并没有使用jdk自己的线程池实现，而是自定了了线程池，自己实现了ThreadPoolExecutor类位于org.apache.tomcat.util.threads包下

jdk线程池

首先回顾一下jdk的线程池实现
在这里插入图片描述
提交一个任务时：
1 如果此时线程池中的数量小于corePoolSize，无论线程池中的线程是否处于空闲状态，都会创建新的线程来处理被添加的任务。

2 如果此时线程池中的数量大于等于于corePoolSize，但是缓冲队列workQueue未满，那么任务被放入缓冲队列。

3 如果此时线程池中的数量大于等于corePoolSize，且缓冲队列workQueue满，但是线程池中的数量小于maximumPoolSize，则建新线程来处理被添加的任务。

4 如果此时线程池中的数量大于corePoolSize，且缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么就需要通过handler所指定的策略来处理此这个任务。

5 线程池中的线程数量大于 corePoolSize时，如果某线程处理完任务后进入空闲状态，空闲时间超过keepAliveTime，该线程将被终止。这样，线程池可以动态的调整池中的线程数到corePoolSize。

重点已经标红处理了：在线程达到corePoolSize个数时，超过的任务是先放在队列里面的

问题：当任务很多又很耗时（比如http请求IO密集型），队列长度怎么设置？过长容易造成任务堆积甚至OOM，最大线程数的设置也将变的没有意义；过短又容易将丢弃任务，tomcat至少要保证请求尽可能交给业务系统去处理

tomcat线程池

在AbstractEndpoint中调用createExecutor方法自定义线程池

public void createExecutor() {
        internalExecutor = true;
        TaskQueue taskqueue = new TaskQueue();
        TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
        executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);
        taskqueue.setParent( (ThreadPoolExecutor) executor);
    }

那么首先看ThreadPoolExecutor的excute方法

public void execute(Runnable command, long timeout, TimeUnit unit) {
        submittedCount.incrementAndGet();
        try {
            super.execute(command);
        } catch (RejectedExecutionException rx) {
            if (super.getQueue() instanceof TaskQueue) {
                final TaskQueue queue = (TaskQueue)super.getQueue();
                try {
                    if (!queue.force(command, timeout, unit)) {
                        submittedCount.decrementAndGet();
                        throw new RejectedExecutionException(sm.getString("threadPoolExecutor.queueFull"));
                    }
                } catch (InterruptedException x) {
                    submittedCount.decrementAndGet();
                    throw new RejectedExecutionException(x);
                }
            } else {
                submittedCount.decrementAndGet();
                throw rx;
            }

        }
    }

tomcat中的线程池有一个额外的属性submittedCount，你可以简单的理解为就是一个计数器，每当有一个任务执行在执行时submittedCount就会加1，当任务执行完成后submittedCount就会减1，具体记录这个数字有什么作用，继续往下看就知道了。

核心还在是父类的的excute方法

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }
  1. 如果当前worker的数量小于核心线程池，调用addWorker
  2. 如果任务能成功入队，并且需要增加一个线程（线程池未关闭并且没有工作线程），调用addWorker
  3. 如果任务入队失败，那么尝试添加一个新线程。如果失败了，拒绝这项任务。

什么是ctl？

我们看到线程池ThreadPoolExecutor内部是通过AtomicInteger类型的 ctl变量来控制运行状态和线程个数；在通过AtomicInteger源码知道器内部就是维护了一个int类型的value值，如下

private volatile int value;

那么通过一个值如何维护状态和个数两个值呢？那么接下来通过底层源码来看大神Doug Lea是如何设计的。


    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
 
 
    // 取高三位表示以下运行时的状态
    // runState is stored in the high-order bits
    private static final int RUNNING     =  -1 << COUNT_BITS;
    private static final int SHUTDOWN    =   0 << COUNT_BITS;
    private static final int STOP        =   1 << COUNT_BITS;
    private static final int TIDYING     =   2 << COUNT_BITS;
    private static final int TERMINATED  =   3 << COUNT_BITS;
 
/**
 * 各个值的二进制表示：
 *
 * 1111 1111 1111 1111 1111 1111 1111 1111 (-1) 
 * 0000 0000 0000 0000 0000 0000 0000 0000 (0) 
 * 0000 0000 0000 0000 0000 0000 0000 0001 (1) 
 * 0000 0000 0000 0000 0000 0000 0000 0010 (2) 
 * 0000 0000 0000 0000 0000 0000 0000 0011 (3)
 *
 * 【分析】：
 * 初始容量值，高三位全是0，低29位全是1；后续操作会以此为基础进行操作
 * CAPACITY                    000 1   1111 1111 1111 1111 1111 1111 1111
 *
 *              ---------------3位-1位 -28位---
 * 【前三位，表明状态位，后29位表明线程个数，即 2^29 - 1 基本够用了】
 *
 * RUNNING(-536870912)         111 0    0000 0000 0000 0000 0000 0000 0000
 * SHUTDOWN(0)                 000 0    0000 0000 0000 0000 0000 0000 0000
 * STOP(536870912)             001 0    0000 0000 0000 0000 0000 0000 0000
 * TIDYING(1073741824)         010 0    0000 0000 0000 0000 0000 0000 0000
 * TERMINATED(1610612736)      011 0    0000 0000 0000 0000 0000 0000 0000
 * 
 */

在这里插入图片描述

结论就是：前三位，表明状态位，后29位表明线程个数，即 2^29 - 1 基本够用了

TaskQueue的offer()方法

既然tomcat用了自己的队列，接下来看一下自定义的TaskQueue类

上述源码已经知道，是否调用addWorker方法取决于TaskQueue的offer()方法要返回false结果（暂不考虑入队成功但是worker随后被销毁的情况）

LinkedBlockingQueue的实现

TaskQueue继承于LinkedBlockingQueue，那么先看LinkedBlockingQueue的offer实现

public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
        final AtomicInteger count = this.count;
        if (count.get() == capacity)
            return false;
        final int c;
        final Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            if (count.get() == capacity)
                return false;
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            signalNotEmpty();
        return true;
    }

很简单：队列中元素个数达到容量上限，则返回false
这也能解释为什么jdk线程池是队列满了才会继续新增线程至最大线程数

tomcat实现TaskQueue：

首先TaskQueue是继承LinkedBlockingQueue的

public class TaskQueue extends LinkedBlockingQueue<Runnable>

再看offer方法

public boolean offer(Runnable o) {
      //we can't do any checks
        if (parent==null) return super.offer(o);
        //we are maxed out on threads, simply queue the object
        if (parent.getPoolSize() == parent.getMaximumPoolSize()) return super.offer(o);
        //we have idle threads, just add it to the queue
        if (parent.getSubmittedCount()<=(parent.getPoolSize())) return super.offer(o);
        //if we have less threads than maximum force creation of a new thread
        if (parent.getPoolSize()<parent.getMaximumPoolSize()) return false;
        //if we reached here, we need to add it to the queue
        return super.offer(o);
    }

注释解释的很明显了：

  1. 如果当前活跃的线程数等于最大线程数，那么就不能创建线程了，因此直接放入队列中
  2. 如果当前提交的任务数小于等于当前活跃的线程数，表示还有空闲线程，直接添加到队列，让线程去执行即可。此处也终于看到了parent.getSubmittedCount方法，用来获取当前提交的任务数，每当有一个任务执行在执行时submittedCount就会加1，当任务执行完成后submittedCount就会减1
  3. 再校验下当前活跃线程数是否小于最大线程数，如果小于，此时就可以创建新的线程了。
  4. 如果以上都不符合，那就代表既没有空闲线程，又达到了最大线程数，也只能放队列了，但是不需要新建线程

在这里插入图片描述

因此Tomcat的线程池策略是，如果没有空闲线程且线程数大于核心线程配置时：继续增加线程至最大核心数为止。

两者对比

tomcat的线程池实现相比jdk实现有以下几点不同：

  1. 队列无限长：高qps时基本不会丢弃任务；但是会有OOM的风险，但是一般单台服务器qps基本不会超过两千
  2. 达到最大线程数之后才会放入队列，低qps时可以快速请求响应不用排队，但是若qps不稳定，会频繁创建销毁线程，对cpu不够友好

行文至此，tomcat为什么要自定义线程池已经讲完了，接下来会补充一下worker的源码分析

worker原理

简介

Worker是ThreadPoolExecutor中的内部类，线程池中的线程，都会被封装成一个Worker类对象，ThreadPoolExecutor维护的其实就是一组Worker对象，其中用集合workers存储这些Worker对象；

Worker类中有两个属性，一个是firstTask，用来保存传入线程池中的任务，一个是thread，是在构造Worker对象的时候，利用ThreadFactory来创建的线程，用来处理线程池队列中的任务；

Worker继承AQS，使用AQS实现独占锁，并且是不可重入的，构造Worker对象的时候，会把锁资源状态设置成-1，因为新增的线程，还没有处理过任务，是不允许被中断的

代码如下

private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
	/**
	 * This class will never be serialized, but we provide a
	 * serialVersionUID to suppress a javac warning.
	 */
	private static final long serialVersionUID = 6138294804551838833L;
	
	/** 这个就是worker持有的线程，也就是线程池中的线程 */    
	final Thread thread;
	
	/** 这个就是提交给线程池的任务 */    
	Runnable firstTask;
	
	/** 每一个线程执行的任务数量的计数器 */  
	volatile long completedTasks;
	
	/**
	 * 我们在调用addWorker方法的时候就会调用这个构造方法，有可能是创建新线程并执行任务，那么firstTask就是传给线程池要执行的任务，如果只是了
	 * 单纯的想创建一个线程，只需要传入null就可以
	 */
	Worker(Runnable firstTask) {
	    setState(-1); // inhibit interrupts until runWorker
	    this.firstTask = firstTask;
	        // 这个是通过线程工厂类创建一个线程，也就是给线程池创建一个线程
	    this.thread = getThreadFactory().newThread(this); 
	}
	
	/** Delegates main run loop to outer runWorker  */
	public void run() {
	    runWorker(this);
	}
	

}

worker其实就是一个Runable，其也是需要构造成一个Thread对象，然后调用Thread.start()方法运行的。只不过在worker的run方法中是定义了一个runWoker的方法。这个方法的主要内容从 for 循环不停的从task队列中获取对应的runable的task，然后同步调用这个task的run()方法。其实就是在某个线程中，不停的拿队列中的任务进行执行。

runWorker

上文已经知道线程池添加一个线程是通过调用addWorker方法，在调用addWorker成功后则会执行Worker对象的run方法，进入runWorker方法逻辑

final void runWorker(ThreadPoolExecutor.Worker w) {
    // 获取当前线程，其实这个当前线程，就是worker对象持有的线程，从线程池中拿到的任务就是由这个线程执行的
    Thread wt = Thread.currentThread();
    // 在构造Worker对象的时候，会把一个任务添加进Worker对象
    // 因此需要把其作为新增线程的第一个任务来执行
    Runnable task = w.firstTask;
    // 上面已经将该任务拿出来准备进行执行了（将firstTask取出赋值给task），则需要将该worker对象即线程池中的线程对象持有的任务清空
    w.firstTask = null;
    // 将AQS锁资源的状态由-1变成0，运行该线程进行中断 因为在创建的时候将state设为-1了，现在开始执行任务了，也就需要加锁了，所以要把state再重新变为0，这样在后面执行任务的时候才能用来加锁，保证任务在执行过程中不会出现并发异常
    // 解锁
    w.unlock();
    // 用来判断执行任务的过程中，是否出现了异常
    boolean completedAbruptly = true;
    try {
        // 线程池中的线程循环处理线程池中的任务，直到线程池中的所有任务都被处理完后则跳出循环
        while (task != null || (task = getTask()) != null) {  // 这一步的getTask()就说明Worker一直在轮询的从队列中获取任务，getTask()方法将从队列获取到的任务返回，赋值给task
            // 给该worker加锁，一个线程只处理一个任务。注意加锁是给worker线程加锁，不是给任务线程加锁，因为worker线程之前一直在轮询地在队列中取任务，但是当执行任务的时候，为了避免执行任务出现异常，就对其加锁
            w.lock();
            // 线程池是否是STOP状态
            // 如果是，则确保当前线程是中断状态
            // 如果不是，则确保当前线程不是中断状态
            if ((runStateAtLeast(ctl.get(), STOP) ||
                    (Thread.interrupted() &&
                            runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                // 注意这里中断的是当前线程，也就是worker对象持有的线程
                wt.interrupt();
            
            try {
                // 扩展使用，在执行任务的run方法之前执行
                beforeExecute(wt, task);
                // 记录执行任务过程中，出现的异常
                Throwable thrown = null;
                try {
                    // 执行任务的run方法   当前线程环境就是worker对象持有的线程，所以本质就是woker对象在执行task任务的run()方法
                    task.run();
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    // 扩展使用，在执行任务的run方法之后执行
                    afterExecute(task, thrown);
                }
            } finally {
                // 执行完任务后，就将任务对象清空
                task = null;
                w.completedTasks++; // 该worker已经完成的任务数+1
                w.unlock();  // 将worker线程地锁释放
            }
        }
        // 正常执行完任务
        completedAbruptly = false;
    } finally {
        // 线程池中所有的任务都处理完后，或者执行任务的过程中出现了异常，就会执行该方法
        processWorkerExit(w, completedAbruptly);
    }
}

这个方法主要做几件事

  1. 如果 task 不为空，则开始执行 task
  2. 如果 task 为空，则通过 getTask()再去取任务，并赋值给 task，如果取到的 Runnable 不为空，则执行该任务
  3. 执行完毕后，通过 while 循环继续 getTask()取任务
  4. 如果 getTask()取到的任务依然是空，那么整个 runWorker()方法执行完毕

这个方法比较简单，如果忽略状态检测和锁的内容，本质就是如果有第一个任务，就先执行之，之后再从任务队列中取任务来执行，获取任务是通过getTask()来进行的。

到这里也就明白了线程池是怎么复用有限的线程数来执行大量的任务
那么worker是如何获取任务的呢?

核心方法 getTask()

这个方法用来向队列中轮询地尝试获取任务。该方法也是ThreadPoolExecutor中的方法。

这里重要的地方是第二个 if 判断，目的是控制线程池的有效线程数量。

由上文中的分析可以知道，在执行 execute 方法时，如果当前线程池的线程数量超过了 corePoolSize 且小于maximumPoolSize，并且 workQueue 已满时，则可以增加工作线程，但这时如果超时没有获取到任务，也就是 timedOut 为 true 的情况，说明 workQueue 已经为空了，也就说明了当前线程池中不需要那么多线程来执行任务了，可以把多于 corePoolSize 数量的线程销毁掉，保持线程数量在 corePoolSize 即可。

// 返回任务Runnable
private Runnable getTask() {
    // timedOut表示 记录上一次从队列中获取任务是否超时
    boolean timedOut = false; // Did the last poll() time out?
    // 自旋
    for (;;) {
        // 这一部分是判断线程池状态
        // 获取线程池的状态和线程池中线程数量组成的整形字段，32位
        // 高3位代表线程池的状态，低29位代表线程池中线程的数量
        int c = ctl.get();
        // 获取高3位的值，即线程池的状态
        int rs = runStateOf(c);
        // 如果线程池状态不是Running状态，并且 线程也不是SHUTDOWN状态 或者任务队列已空
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            // 则将线程池中的线程数量减1  就是说该线程已经不是运行状态了，所以要这个worker线程也没有用了，直接将该worker去掉。这个是原子操作
            decrementWorkerCount();
            //返回一个空任务，因为：
            // 1：如果任务队列已空，则想返回任务也没有
            // 2:如果线程池处于STOP或者之上的状态，则线程池不允许再处理任务
            return null;
        }
        // 这一部分是判断线程池有效线程数量
        // 获取低29位的值，即线程池中线程的数量
        int wc = workerCountOf(c);
        // timed是否需要进行超时控制
        // allowCoreThreadTimeOut默认false
        // 当线程池中线程的数量没有达到核心线程数量时，获取任务的时候允许超时  如果将allowCoreThreadTimeOut设为true，那也不允许超时
        // 当线程池中线程的数量超过核心线程数量时，获取任务的时候不允许超时   
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; // 这个很好理解
 
        // wc > maximumPoolSize的情况是因为可能在此方法执行阶段同时执行了setMaximumPoolSize方法；
        // timed && timedOut 如果为true，表示当前操作需要进行超时控制，并且上次从阻塞队列中获取任务发生了超时
        // 接下来判断，如果有效线程数量大于1，或者阻塞队列是空的，那么尝试将workerCount减1；
        // 如果减1失败，则continue返回重试
        // 如果wc == 1时，也就说明当前线程是线程池中唯一的一个线程了。
        if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }
 
        // 如果上面都没问题，就可以获取任务了
        try {
            // 获取任务
            // 如果timed = true ，说明需要做超时控制，则根据keepAliveTime设置的时间内，阻塞等待从队列中获取任务
            // 如果timed = false，说明不需要做超时控制，则阻塞，直到从队列中获取到任务为止
            Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
            // 如果获取到任务，则把任务返回
            if (r != null)
                return r;
            // 执行到这里，说明在允许的时间内，没有获取到任务
            timedOut = true;
        } catch (InterruptedException retry) {
            // 获取任务没有超时，但是出现异常了，将timedOut设置为false
            timedOut = false;
        }
    }
}

注意，这里取任务会根据工作线程的数量判断是使用BlockingQueue的poll(timeout, unit)方法还是take()方法。

poll(timeout, unit)方法会在超时时返回null，如果timeout<=0，队列为空时直接返回null。

take()方法会一直阻塞直到取到任务或抛出中断异常。

所以，如果keepAliveTime设置为0，当任务队列为空时，非核心线程取不出来任务，会立即结束其生命周期。

当允许超时控制时：workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) 会在keepAliveTime后返回null，返回null的结果是退出完成循环，销毁当前线程；这就说明了keepAliveTime参数的含义，线程最大空闲时间了

提出一个问题，这个keepAliveTime参数是否对核心线程也生效呢，文末会有答案

那么接下来，worker是如何销毁的呢？

核心方法 processWorkerExit()

runWorker 的 while 循环执行完毕以后，在 finally 中会调用 processWorkerExit()方法，来销毁工作线程。该方法就是判断当前线程是需要将其删除还是继续执行任务。该方法也是ThreadPoolExecutor中的方法。

private void processWorkerExit(ThreadPoolExecutor.Worker w, boolean completedAbruptly) {
    // 如果 completedAbruptly = true ，则线程执行任务的时候出现了异常，需要从线程池中减少一个线程
    // 如果 completedAbruptly = false，则执行getTask方法的时候已经减1，这里无需在进行减1操作
    if (completedAbruptly)
        decrementWorkerCount();
    
    // 获取线程池的锁，因为后面是线程池的操作，为了并发安全，需要对线程池加锁
    final ReentrantLock mainLock = this.mainLock;
    // 线程池加锁
    mainLock.lock();
    try {
        // 统计该线程池完成的任务数
        completedTaskCount += w.completedTasks;
        // 从线程池中移除一个工作线程    works是线程池持有的一个集合  
        workers.remove(w); // 将没用的worker去掉，也就是当前传入的worker
    } finally {
        // 线程池解锁
        mainLock.unlock();
    }
    // 根据线程池的状态，决定是否结束该线程池
    tryTerminate(); // 钩子方法
 
    // 判断线程池是否需要增加线程
    // 获取线程池的状态
    int c = ctl.get();
    // -当线程池是RUNNING或SHUTDOWN状态时
    // --如果worker是异常结束（即completedAbruptly为false），那么会直接addWorker；
    // ---如果allowCoreThreadTimeOut = true，并且等待队列有任务，至少保留一个worker；
    // ---如果allowCoreThreadTimeOut = false，活跃线程数不少于corePoolSize
    if (runStateLessThan(c, STOP)) { // 线程池状态小于STOP，就说明当前线程池是RUNNING或SHUTDOWN状态
        // 如果worker是异常结束的，不进入下面的分支，直接去addWorker
        if (!completedAbruptly) {
            // 根据allowCoreThreadTimeOut的值，来设置线程池中最少的活跃线程数是0还是corePoolSize
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            // 如果等待队列中有任务，要至少保留一个worker
            if (min == 0 && ! workQueue.isEmpty())
                // 至少保留一个worker
                min = 1;
            // 如果活跃线程数大于等于min，直接返回，不需要再调用addWorker来增加线程池中的线程了
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        // 增加线程池中的worker
        addWorker(null, false);
    }
}

1.执行decrementWorkerCount方法将线程池中的线程数量减1 ，因为当前worker已经取出去任务了

  1. 如果 completedAbruptly = true ，则代表线程执行任务的时候出现了异常，需要执行
  2. 如果 completedAbruptly = false，则执行getTask方法的时候调用过decrementWorkerCount方法将线程池中的线程数量减1，这里无需在进行减1操作

2.将worker从wokers集合中移除
3.根据线程池的状态，决定是否结束该线程池
4.判断是否再调用addWorker方法

其中 int min = allowCoreThreadTimeOut ? 0 : corePoolSize;根据allowCoreThreadTimeOut的值，来设置线程池中最少的活跃线程数是0还是corePoolSize

  1. 如果worker是异常结束（即completedAbruptly为false），那么会直接addWorker；
  2. 如果allowCoreThreadTimeOut = true，并且等待队列有任务，至少保留一个worker；
  3. 如果allowCoreThreadTimeOut = false，活跃线程数不少于corePoolSize

说明

  1. 如果核心线程出了异常也是会被销毁的，只不过销毁后还会调用addWorker方法增加一个线程
  2. allowCoreThreadTimeOut为true时，min为0，则表明，核心线程在allowCoreThreadTimeOut为true时也是会随着worker的销毁（没有任务可取既空闲了keepAliveTime时间）而销毁，并且不会调用addWorker来增加一个线程

参考：
https://blog.csdn.net/cy973071263/article/details/131484384
https://blog.csdn.net/u014307520/article/details/117787133
https://blog.csdn.net/kkkkk0826/article/details/103405813

Ethan_199402
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Tomcat6.0共享线程池配置
05-03
详细讲解了Tomcat6.0共享线程池配置和性能调优的方法
tomcat自定义证书
07-31
https://blog.csdn.net/q975583865/article/details/80249375
在Tomcat中配置404自定义错误页面详解
09-30
主要介绍了在Tomcat中配置404自定义错误页面全解,需要的朋友可以参考下
Tomcat线程池实现简介
04-14
Tomcat是使用最广的Java Web容器，功能强大，可扩展性强
Tomcat 线程池
一个菜鸡的博客
07-09 2456
Tomcat 是一个流行的 Java Web 服务器，它使用线程池来处理客户端请求。线程池是一组预先创建的线程，用于执行并发任务，以提高性能和资源利用率。在 Tomcat 中，线程池被用来处理传入的 HTTP 请求。当客户端发送请求时，Tomcat 会从线程池中获取一个可用的线程来处理该请求。处理完请求后，线程将返回线程池，并在下一个请求到来时再次被重用。Tomcat 的线程池配置可以通过编辑server.xml文件来进行。maxThreads：指定线程池中的最大线程数。
Tomcat线程池实现简介(五)
hulefei29的专栏
01-22 4869
 介绍了tomcat、jetty和resin三种JavaWeb容器的线程池后，按照惯例应该比较它们的优缺点。不过先总结线程池的特点。线程池作为提高程序处理数据能力的一种方案，应用非常广泛。大量的服务器都或多或少的使用到了线程池技术，不管是用Java还是C++实现，线程池都有如下的特点：线程池一般有三个重要参数：1.最大线程数。在程序运行的任何时候，线程数总数都不会超过这个数
tomcat线程池的实现
Freda的专栏
08-21 821
Tomcat的线程池主要使用了ThreadPool.java、ThreadPoolRunnable.java、ThreadWithAttributes.java，其中ThreadPoolRunnable.java是一个接口，所有的需要使用线程池的服务都可以实现这个接口。而实现的核心则再ThreadPool.java中的两个内部类：MonitorRunnable.java和ControlRunnab
tomcat 线程池设置
weixin_33775572的博客
09-26 377
2019独角兽企业重金招聘Python工程师标准>>> ...
tomcat线程池
weixin_43803688的博客
04-18 7679
tomcat线程池
tomcat配置线程池
cafelication的专栏
10-29 515
随着业务量的上升，tomcat的请求量变大， 这时默认的tomcat线程数已经有点吃紧，（默认200），这时就要我们自己手动配置tomcat线程池，已解决线程阻塞问题； 下面就切入主题： 首先，修改tomcat 根目录配置文件 conf/server.xml <Executor name="tomcatThreadPool" namePrefix="pro—thread-exec...
基于tomcat的连接数与线程池详解
09-30
下面小编就为大家带来一篇基于tomcat的连接数与线程池详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
仿写一个tomcat（含线程池配置）超详细！！
adru的博客
08-18 157
利用注解对servlet类进行标记，之后将它标记中的请求地址和全类名存入map中，利用反射拿到类信息，调用类的方法，利用socket和浏览器交互，监听8080端口，之后将请求信息拿到，处理其中的信息拿到请求url和参数信息
JUC之线程池ThreadPoolExecutor
Zeng_1997的博客
11-27 433
8. 共享模型之工具 8.1 线程池 池化技术相比大家已经屡见不鲜了，线程池、数据库连接池、Http 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。 线程池提供了一种限制和管理资源（包括执行一个任务）。 每个线程池还维护一些基本统计信息，例如已完成任务的数量。 这里借用《Java 并发编程的艺术》提到的来说一下使用线程池的好处： 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。当任务到达时，任务可以不需要的等到线
并发编程学习（十四）：tomcat线程池
weixin_40482816的博客
05-31 2006
Tomcat 的核心功能有两个，分别是负责接收和反馈外部请求的连接器 Connector，和负责处理请求的容器 Container。其中连接器和容器相辅相成，一起构成了基本的 web 服务 Service。每个 Tomcat 服务器可以管理多个 Service。ConnectorContainer由 Engine、Host、Context和Wrapper 四个容器组成ServiceConnector 和 Container 两个核心组件。
Tomcat线程池详解
凌小星的专栏
11-14 6463
写在前面的话  最近一直都在研究Java的线程池ThreadPoolExecutor，但是虽然它那么好，但是在实际的用途中怎么去用，对于我来说就不知道如何下手了，还好有开源社区我们可以了解很多项目中所运用到的线程池，比如最熟悉的就是Apache Tomcat了，相信都对它不默生，一个Apache软件基金下的一个开源Web容器，所以今天就来聊一下Tomcat的线程池实现。准备工作  首先去Apache
tomcat线程池-深度分析tomcat线程池设计与现实
自恃无情的博客
11-15 1073
深入分析tomcat 线程池执行原理以及核心属性
Tomcat基本使用与控制台乱码解决方式
最新发布
m0_55956769的博客
04-27 205
Tomcat基本使用与控制台乱码解决方式
Tomcat
wuweixiaoyue的博客
04-23 1178
Tomcat 是一个 Http服务器，里面帮助我们部署了许多网站Tomcat 是Java圈子中广泛使用的 HTTP 服务器（HTTP 服务器有很多种，Nginx是各个领域中最知名的）Tomcat 是一个 webapp 的容器容器是一个很宽泛的概念，叫容器的有很多webapp 是指的是网站(由后端代码 + 前端代码构成)，同时一个 Tomcat 服务器上可以部署多个网站Servlet 就是依赖 Tomcat 运行的默认端口：Tomcat 有两个默认端口，一个是8080，一个是8005。
Mybatis入门，day2，动态SQL
weixin_67485772的博客
04-22 977
动态 SQL 是 MyBatis 的强大特性之一。在 JDBC 或其它类似的框架中，开发人员通常需要手动拼接 SQL 语句。根据不同的条件拼接 SQL 语句是一件极其痛苦的工作。例如，拼接时要确保添加了必要的空格，还要注意去掉列表最后一个列名的逗号。而动态 SQL 恰好解决了这一问题，可以根据场景动态的构建查询。
springboot tomcat线程池配置在哪个类？
04-10
您可以在Spring Boot的配置文件application.properties中进行Tomcat线程池的配置。...您还可以在Spring Boot应用程序中创建一个名为TomcatWebServerFactoryCustomizer的Bean，以便更详细地自定义Tomcat线程池。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值