线程池与ThreadPoolExecutor学习笔记

       学习和使用Java的时间也不算短了，一直想找个机会好好学习线程池相关的技术细节，最近正好比较闲，因此抽空来把JDK 1.7线程池的实现给研究了一下。
       线程池技术，不管是对于服务器端开发还是客户端开发都很重要。线程池最大的好处在于减少对象的创建和销毁带来的资源消耗。在面向对象程序编程中，创建和销毁对象是很消耗资源的。对于Java来说，更是如此，Java虚拟机会跟踪每一个对象，以便在对象被销毁后进行垃圾回收，这就是一些“池化技术”产生的原因。服务器端开发我不太熟悉，对于客户端开发来说。经常需要在非UI线程处理一些工作，如果每次都创建一个线程的话，对于CPU、内存、电池都受限制的手机来说，这显然是不可接受的。因此我们在进行Android开发时也采用线程池的技术来避免资源的消耗。由于我是Android程序猿，使用的语言是Java，因此我就使用JDK的线程池实现来讲解。
       想要学习了解一个类，首先要从它的构造函数开始学习。首先我们来看一下它的一个常见的构造函数。

/*** @param corePoolSize 线程池中维护的目标线程个数，在运行一段时间以后线程个数与corePoolSize相等* @param maximumPoolSize 线程池中中维护的最大线程个数* @param keepAliveTime 当线程池中的线程个数大于corePoolSize，并且由有处于idle状态的线程时，最大的等待下一个任务的时间* @param unit keepAliveTime的时间单元* @param workQueue 保存要运行的Runnable对象的的队列* @param threadFactory 当executor需要创建新的线程时使用的factory*/public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,             threadFactory, defaultHandler);    }

       由构造函数可知，ThreadPoolExecutor可以创建一个线程池不断处理提交过来的Runnable对象，线程池在运行一段时间以后线程的个数等于corePoolSize，maximumPoolSize是线程池中最大的线程个数，当线程池中的线程个数大于corePoolSize并且由处于idle状态的线程，经过keepAliveTime之后线程会被销毁。线程池使用BlockingQueue来保存提交执行Runnable，当queue为空时，线程持续等待并被阻塞住。
       接下来说一下ThreadPoolExecutor这个类中贯穿始终的一些变量和方法，这些正是ThreadPoolExecutor类设计的巧妙之处。ctl是一个atomic integer，它负责保存线程池的运行状态以及当前线程池的worker线程个数。整个线程池的最大容量是2^29 - 1，也就说ctl的低29位用来存储worker线程的个数，ctl的高三位，用来存储线程池的状态，如RUNNING、SHUTDOWN、STOP等等。源码中关于这么设计的解释是2^29 - 1也已经是一个非常大的数了，以后再扩展的话再换成atomic long也很方便，而且由于在ThreadPoolExecutor中需要频繁查询线程池状态以及worker线程个数，而移位运算效率又是相对比较高的，因此采用这样的方式来设计。废话少说，下面直接上源码。

    //负责保存线程池状态以及worker线程数量    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));    private static final int COUNT_BITS = Integer.SIZE - 3;    //worker线程数量最大值，2^29 - 1    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;    // Packing and unpacking ctl    //取出ctl的高3位，获得线程池状态    private static int runStateOf(int c)     { return c & ~CAPACITY; }    //取出ctl的低29位，获得worker线程个数    private static int workerCountOf(int c)  { return c & CAPACITY; }    private static int ctlOf(int rs, int wc) { return rs | wc; }

       接下来是ThreadPoolExecutor的一些重要方法。

public void execute(Runnable command) {        //首先判空，空则抛异常        if (command == null)            throw new NullPointerException();        int c = ctl.get();        //如果worker线程个数小于corePoolSize        if (workerCountOf(c) < corePoolSize) {            //调用addWorker方法，此方法稍后解释            //大致就是新增一个线程，并把command作为此线程的第一个任务            //如果新增并且执行成功，直接返回            if (addWorker(command, true))                return;            c = ctl.get();        }        //如果worker线程个数 >= corePoolSize        //判断线程池运行状态，并且将command添加到保存任务的Queue中        if (isRunning(c) && workQueue.offer(command)) {            int recheck = ctl.get();            //再次检查线程池状态，如果挂了，则从Queue中移除command，并且关闭线程池            if (! isRunning(recheck) && remove(command))                reject(command);            //否则线程池正常运行的话，如果worker线程的个数等于0，那么则新增线程            //这也就是我工作的项目中使用的线程池corePoolSize和maximumPoolSize相同的原因            //因为线程个数到达corePoolSize之后新增线程的条件很严苛，绝大多数情况下maximumPoolSize是无用的            else if (workerCountOf(recheck) == 0)                addWorker(null, false);        }        //当线程池的状态不是running        //或者虽然处于running，但是队列已经满了，拒绝添加新任务        else if (!addWorker(command, false))            reject(command);    }

       对于execute方法的总结，（1）当线程池接收一个新的任务时，如果当前线程个数小于corePoolSize，那么直接调用addWorker方法新增线程，并且将command作为第一个任务进行执行。（2）如果当前线程个数大于等于corePoolSize，首先判断线程池运行状态，如果状态正常，然后试图将任务添加到队列中。如果线程池状态异常或者缓存队列已经满了，尝试新增worker线程，如果新增worker线程仍失败，则拒绝command。（3）线程个数大于等于corePoolSize，线程池状态正常，并且将任务成功添加到缓存队列中，那么再次检查线程池状态。如果线程池挂了，那么拒绝任务。否则再次检查状态仍正常的话，如果worker线程个数为0，那么新增worker线程。

    /**    * @param firstTask 新增线程执行的第一个runnable对象    * @paran core 是否以corePoolSize为线程个数限制    */    private boolean addWorker(Runnable firstTask, boolean core) {        retry:        for (;;) {            int c = ctl.get();            int rs = runStateOf(c);            //检查线程池状态            if (rs >= SHUTDOWN &&                ! (rs == SHUTDOWN &&                   firstTask == null &&                   ! workQueue.isEmpty()))                //状态异常则直接返回                return false;            for (;;) {            //检查worker线程数量                int wc = workerCountOf(c);                if (wc >= CAPACITY ||                    wc >= (core ? corePoolSize : maximumPoolSize))                    //状态异常则直接返回                    return false;                //增加worker线程数量                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 {            //创建新的worker对象            w = new Worker(firstTask);            final Thread t = w.thread;            if (t != null) {                final ReentrantLock mainLock = this.mainLock;                mainLock.lock();                try {                    // Recheck while holding lock.                    // Back out on ThreadFactory failure or if                    // shut down before lock acquired.                    int rs = runStateOf(ctl.get());                    if (rs < SHUTDOWN ||                        (rs == SHUTDOWN && firstTask == null)) {                        if (t.isAlive()) // precheck that t is startable                            throw new IllegalThreadStateException();                        //往worker线程set添加对象                        workers.add(w);                        int s = workers.size();                        if (s > largestPoolSize)                            largestPoolSize = s;                        workerAdded = true;                    }                } finally {                    mainLock.unlock();                }                //如果添加worker成功，执行runnable                if (workerAdded) {                    t.start();                    workerStarted = true;                }            }        } finally {            if (! workerStarted)                addWorkerFailed(w);        }        return workerStarted;    }

       addWorker方法总结：此方法主要是完成添加worker对象的工作，添加成功之后则执行 runnable，不过 runnable有可能为空。

    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在addWorker 被创建之后，run方法直接被调用，而run方法又会调用至此方法。在此方法中，通过while 循环，不断调用getTask从blockingQueue中取出任务来执行，如果缓存队列为空，则线程被阻塞，直到有新的任务被放入缓存队列中            while (task != null || (task = getTask()) != null) {                w.lock();                // If pool is stopping, ensure thread is interrupted;                // if not, ensure thread is not interrupted.  This                // requires a recheck in second case to deal with                // shutdownNow race while clearing interrupt                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);        }    }

       runWorker()的方法的核心在于通过while 循环，不断调用getTask从blockingQueue中取出任务来执行，如果缓存队列为空，则线程被阻塞，直到有新的任务被放入缓存队列中。
       至此，线程池的简单学习笔记已经到此结束了，线程池对于移动端开发来说有着非常重要的意义，必须要掌握好！