面对海量网络请求，Tomcat线程池如何进行扩展？

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    //...
    
	//启动所有核心线程
    prestartAllCoreThreads();
}

public class TaskQueue extends LinkedBlockingQueue<Runnable>

//parent是该队列对应的线程池，parent就是用来判断什么时候创建非核心线程的
private transient volatile ThreadPoolExecutor parent = null;
//获取当前工作线程数量
parent.getPoolSizeNoLock()
//获取提交的任务数量    
parent.getSubmittedCount()

//调用offer 说明工作线程数量大于等于核心线程数
public boolean offer(Runnable o) {
    //没有parent直接入队
    if (parent==null) {
        return super.offer(o);
    }
    
    //如果线程池的工作线程数量等于最大线程数量则直接入队
    if (parent.getPoolSizeNoLock() == parent.getMaximumPoolSize()) {
        return super.offer(o);
    }
    
    //来到这说明当前工作线程小于最大线程数量，表面可以创建非核心线程
    
    //如果提交的任务数小于等于工作线程数量，说明有的线程空闲 放入队列
    if (parent.getSubmittedCount() <= parent.getPoolSizeNoLock()) {
        return super.offer(o);
    }
    
    //到此说明提交任务数大于工作线程数量
    //如果还没到最大线程数量，则返回false 后续创建非核心线程
    if (parent.getPoolSizeNoLock() < parent.getMaximumPoolSize()) {
        return false;
    }
    
    //默认入队
    return super.offer(o);
}

	private void executeInternal(Runnable command) {
        if (command == null) {
            throw new NullPointerException();
        }
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true)) {
                return;
            }
            c = ctl.get();
        }
    	//工作线程数量大于核心线程数量 调用offer
    	//工作线程数量小于最大线程数量 并且 提交任务数量大于工作线程数量 offer返回false
        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);
            }
        }
    	//调用addWorker创建非核心线程
        else if (!addWorker(command, false)) {
            reject(command);
        }
    }

public void execute(Runnable command) {
    //原子类自增记录提交任务数量
    submittedCount.incrementAndGet();
    try {
        //线程核心流程
        executeInternal(command);
    } catch (RejectedExecutionException rx) {
        //捕获拒绝异常
        if (getQueue() instanceof TaskQueue) {
            final TaskQueue queue = (TaskQueue) getQueue();
            //拒绝后再次尝试把任务加入队列
            if (!queue.force(command)) {
                submittedCount.decrementAndGet();
                throw new RejectedExecutionException(sm.getString("threadPoolExecutor.queueFull"));
            }
        } else {
            //其他队列则继续抛出拒绝异常
            submittedCount.decrementAndGet();
            throw rx;
        }
    }
}