ThreadPoolExecutor复用流程的一点理解

ThreadPoolExecutor复用流程的一点理解

一、背景

​ 最近在学并发编程的线程池，看了很多文章和视频，我认为都没有讲到线程池的核心。大家都说线程池能减少创建线程的消耗和销毁时间，但是却不解释是怎么做到的，而仅仅只是不断重复讲如果大于核心线程数会怎么样，大于最大线程数会这么样。。感觉本末倒置了。我觉得得研究一下，不然线程池在我眼里就是个多余的东西。

二、关键代码

​ 首先我们理清execute这个方法背后的执行顺序，我只一一按顺序列出，知道关键的地方才会加以特别说明：

• execute()

• addworker(w)

• Work a = new Worker(w)

  work重写了run方法，也就是runwork()

• a.start()

  以上就是一个线程添加到线程池的逻辑顺序，这个并不能体现复用。我们接着看，到了a.start()这个一步，线程就会去执行run（），work重写了run，也就跑到了runwork（）里面：这个是关键。

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            // 第一次进来的时候task不为空
            // 第二进进来的时候因为final执行的原因，task为null，就会执行gettask了
            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);
        }
    }

本质是什么呢：可以看见这个线程的run方法是个while循环，其中getTask会被阻塞住，这个我们后面讲 ，因此其实就是该线程不会结束。

下面就要看看那getTask在干什么了：

 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);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

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

            try {
                // 前面的不用管，看着在这行判断。
                // timed 如果当前线程数 大于核心线程数，那么就为true
                // 当前线程数大于核心线程数，那么就把当前线程放到队列中
                // 当前线程数小于核心线程数，就去队列中拿去
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

可以用文字来描述，一个线程execute的过程（假设该线程池核心数量2个），比方说线程A，第一次进来，会添加到work数组中，然后执行run，然后到gettask发现队列是空的，他的queue.take()因此一直阻塞着（因此线程不会结束），再来个线程B，一样执行完然后在queue.tak()阻塞，再来一个线程C，因为现在大于核心线程数，他会经过一个队列的offer方法（见下面的代码），把该线程放到队列中，因此前面两个线程的take就可以拿到线程了，于是复用了！通过debug就发现这个c线程没有经过start（）了，于是减少了线程创建的时间！妙！

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();
        }
    	// 但第三个线程进入的时候，就大于核心线程数目了，因此会执行offer！
    	// 明显的但offer执行失败了，也就是队列满了，就会到下一个else if
        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);
        }
    	// 只要不超过max线程，那么，就还会继续创建线程，是个全新的线程，直接运行start
        else if (!addWorker(command, false))
            reject(command);
    }

三、小结

回过头来思考：复用的本质就是，while循环让run方法不停止，然后配合队列进行阻塞。