java 线程池里面嵌套线程池

线程池（ThreadPoolExecutor）是作为一个统一管理调度线程的机制而出现。线程池中的线程数量在初始化时定义，线程执行完成并不进行销毁，所以线程池的优点显而易见：

1、并不会因为线程创建太多而导致内存泄漏；

2、节省过多的线程的创建和销毁而产生的时间和空间上的花销。

 

从而可以看出如果程序需要大量的线程去工作的时候，线程池才有存在的意义。。。。。。

---

一、线程池工作流程（根据方法分析）

线程池在收到程序提交的任务之后判断当前线程数是否超过corePoolSize，没有超过就创建线程执行，否则判断任务数有没有超过maximumPoolSize，没有则放入任务队列workQueue，否则执行拒绝策略拒绝接收任务。线程执行完成自己的任务之后会通过runWorker()一直执行队列中的任务，直到执行完所有任务。如果线程池设置allowCoreThreadTimeOut 参数为true则线程定时生效，反之不超过核心线程数的线程可以一直等待新的任务。

调用流程：execute()-------> addWorker() --------> runWorker() ---------->getTask();

 

二、线程池重要属性

如下是线程池实例中最重要的几个属性：

实例名	解释
corePoolSize	当前线程池实例中允许同时执行的最大线程数
maximumPoolSize	当前线程池实例允许存在的最大线程数
keepAliveTime	当前线程池中空闲线程在终止前等待的最大时间（线程空闲下来到被kill的时间）
unit	keepAliveTime 的时间单位
workQueue	当前线程池的deng消息队列
threadFactory	创建线程的工厂类
handler	由于达到线程边界和队列容量而阻止执行时要使用的处理程序
workers	当前线程池实例中的线程集合
ctl	线程池控制器，二进制前三位表示线程池状态，后29位表示线程数量

线程池常量：

常量名	意义
RUNNING	线程运行状态：1110 0000 0000 0000 0000 0000 0000 0000，-536870912 线程池正常运行状态
SHUTDOWN	线程关闭状态：0000 0000 0000 0000 0000 0000 0000 0000，0   线程池调用shutdown()方法进入
STOP	线程停止状态：0010 0000 0000 0000 0000 0000 0000 0000，536870912   调用shutdownNow()进入
TIDYING	线程整理状态：0100 0000 0000 0000 0000 0000 0000 0000，1073741824  线程池为空
TERMINATED	线程结束状态：0110 0000 0000 0000 0000 0000 0000 0000，1610612736  关闭线程池，terminated()执行完成进入
CAPACITY	获取ctl前三位或者后29位标识：0001 1111 1111 1111 1111 1111 1111 1111

 

三、内部类Worker

线程池内部并不是以线程为基本单位实现的，而是以worker为基本单位，每个worker实例包含一个线程实例和一个可执行任务（其实还是一个线程）。内部提供了可执行方法run()用于执行该任务。

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        private static final long serialVersionUID = 6138294804551838833L;

        /** 线程对象，通过线程工厂初始化 */
        final Thread thread;
        /** 可执行任务对象 */
        Runnable firstTask;
        /** 当前线程执行任务计数器 */
        volatile long completedTasks;

        /**
         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
         */
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        /** 执行任务方法，调用线程池方法runWorker()  */
        public void run() {
            runWorker(this);
        }

        ...
    }

 

四、线程池重要方法

1、调用线程池处理任务入口：

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        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();
            //重新获取状态，如果不是running状态，remove任务。
            if (! isRunning(recheck) && remove(command))
                reject(command);//删除成功则使用线程池的hander策略处理任务
            //如果线程池在运行状态，但是线程池没有线程，则创建新线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //创建新线程失败，则通过线程池的hander策略处理任务
        else if (!addWorker(command, false))
            reject(command);
    }

2、添加待执行任务到workers，并启动线程：

private boolean addWorker(Runnable firstTask, boolean core) {
        retry://监控线程池状态
        for (;;) {
            int c = ctl.get();

            //获取线程池状态（ctl二进制前三位表示）
            int rs = runStateOf(c);

            //如果线程池不是running状态或者线程池无任务，则不添加worker
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                //获取当前线程池的worker数量（ctl二进制后边29位表示）
                int wc = workerCountOf(c);

                //若线程池为STOP， TIDYING， TERMINATED三种状态或者worker数量超出限制时，不再添加worker
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread; //通过ThreadFactory创建线程
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();  //添加线程池锁，创建任务完成后解锁，防止线程池状态混乱
                try {
                    //查看线程池状态，同上
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start(); //启动任务（线程）
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted; //返回创建和启动线程结果（启动成功才算成功）
    }

3、运行队列中的任务（只要队列中有任务存在，不退出线程）

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            //当前worker没有任务（任务已经被执行了，线程在等待）则执行队列中第一个任务（如果存在等待任务）
            while (task != null || (task = getTask()) != null) {
                w.lock();
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        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 {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

4、获取队列中的等待任务

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // 是否允许线程超时
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                //如果线程数量大于核心线程数量，并且设置allowCoreThreadTimeOut 为true时，不允许线程超时，超时返回空。反之线程一直等待新的任务。
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }