共同学习Java源代码-多线程与并发-ThreadPoolExecutor类(六)

    private List<Runnable> drainQueue() {
        BlockingQueue<Runnable> q = workQueue;
        ArrayList<Runnable> taskList = new ArrayList<Runnable>();
        q.drainTo(taskList);
        if (!q.isEmpty()) {
            for (Runnable r : q.toArray(new Runnable[0])) {
                if (q.remove(r))
                    taskList.add(r);
            }
        }
        return taskList;
    }


将任务队列放入一个新的ArrayList中的方法


先获取workQueue 然后创建taskList


调用工作队列的drainTo方法将队列里的worker放入taskList


如果判断出来队列仍然不为空 就遍历队列 删除worker 将worker添加进taskList


最后返回taskList






  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 (;;) {
                int wc = workerCountOf(c);
                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;


            }
        }




        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            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;
    }


这个是添加worker的方法


定义一个名叫retry的无限for循环


先获取ctl 也就是线程池状态的控制单元 然后获取状态rs


判断rs大于等于SHUTDOWN成立 且 这三个条件有至少一个不成立：1.rs为SHUTDOWN 2.firstTask也就是参数为空 3.工作队列workQueue不为空 


如果上述判断为true 就返回false 


进入一个内层的for循环 


获取worker数wc 判断两个条件中有一个成立：1.wc大于等于CAPACITY也就是线程池的容量 2.如果参数core为true wc是否大于等于corePoolSize 如果参数core为false wc是否大于等于maximumPoolSize


如果上述判断为true 就返回false


调用compareAndIncrementWorkerCount方法增加workerCount 如果方法返回true 就退出循环retry 这个方法只是计数器加一 所以底下要上锁
再次获取ctl 根据ctl获取当前状态 如果当前状态和rs不一致 就跳出并继续retry循环


内层for循环结束 外层retry循环也结束


创建两个布尔值变量workerStarted和workerAdded 都赋值为false 创建一个Worker变量w赋为空


进入try块


给w初始化 将参数传入 


获取新worker的线程


判断这个线程不为空


用mainLock上锁


进入内层try块


从新获取状态rs 


判断两个条件中有一个成立：1.rs的状态值小于SHUTDOWN 2.rs为SHUTDOWN且firstTask为空


如果上面判断成立 继续内层判断如果该线程是alive的也就是一个存活的线程 无法从新启动 就抛出异常


将新建的worker添加进workers队列 获取workers的长度s 判断s和largestPoolSize的大小 如果s大于后者 就将后者赋为s


workerAdded赋为true


内层try块的finally块中将mainLock解锁


如果workerAdded为true 


启动worker的线程 将workerStarted设为true


外层try块的finally块中 判断如果workerStarted为false 调用addWorkerFailed 将新建的worker传进去


最后返回workerStarted