ThreadPoolExecutor源码解析

先来看下ThreadPoolExecutor在tomcat7中的应用

    /** 创建请求处理线程池 */
    public void createExecutor() {
        internalExecutor = true;

        /** 创建任务队列 */
        TaskQueue taskqueue = new TaskQueue();

        /** 创建任务线程工厂 */
        TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());

        /** 创建线程池ThreadPoolExecutor,核心线程10个，最大请求处理线程200个，线程空闲时间60s */
        executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);

        /** 往任务队列中加入ThreadPoolExecutor */
        taskqueue.setParent( (ThreadPoolExecutor) executor);
    }

    /** 创建子容器启动关闭线程池 */

    protected void initInternal() throws LifecycleException {
        BlockingQueue<Runnable> startStopQueue = new LinkedBlockingQueue<Runnable>();
        /** 创建一个子容器启动和停止线程池,核心线程1个，最大线程数1个，空闲时间10TimeUnit */
        startStopExecutor = new ThreadPoolExecutor(
                getStartStopThreadsInternal(),
                getStartStopThreadsInternal(), 10, TimeUnit.SECONDS,
                startStopQueue);
        /**
         * keepAliveTime
         * 设置线程在终止前可以保持空闲的时间限制。如果池中的当前线程数多于核心线程数，在不处理任务的情况下等待这一时间段之后，多余的线程将被终止。
         */
        /** 允许核心线程在空闲时间超过keepAliveTime时将会终止,但是设置这个方法,keepAliveTime必须大于0,否则核心线程执行完就终止，线程池就无存在意义 */
        startStopExecutor.allowCoreThreadTimeOut(true);
        super.initInternal();
    }

public void execute(Runnable command) {

       // 如果任务为null,则抛出异常 

       if (command == null)

            throw new NullPointerException();

        // 如果当前线程池大小大于等于核心池大小

        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
            if (runState == RUNNING && workQueue.offer(command)) {
                if (runState != RUNNING || poolSize == 0)
                    ensureQueuedTaskHandled(command);
            }
            else if (!addIfUnderMaximumPoolSize(command))
                reject(command); // is shutdown or saturated
        }

}

private boolean addIfUnderCorePoolSize(Runnable firstTask) {
        Thread t = null;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (poolSize < corePoolSize && runState == RUNNING)

                // 添加一个工作线程
                t = addThread(firstTask);
        } finally {
            mainLock.unlock();
        }
        if (t == null)
            return false;
        t.start(); // 启动工作线程
        return true;
}

private Thread addThread(Runnable firstTask) {
        Worker w = new Worker(firstTask);
        Thread t = threadFactory.newThread(w);
        if (t != null) {
            w.thread = t;

            // 往线程池中添加一个线程
            workers.add(w);

            // 当前线程池大小
            int nt = ++poolSize;
            if (nt > largestPoolSize)

                // 线程池历史最大线程数
                largestPoolSize = nt;
        }
        return t;
}