ThreadPoolExecutor内部机制

作者: 慧明小和尚下山去化斋 | 来源:发表于2017-02-12 17:11 被阅读0次

    前言

    众所周知,JDK为我们提供了一系列线程池类,ThreadPoolExecutor就是一个很典型的实现,以下对JDK的线程池机制分析都将围绕这一个类来描述。

    开始

    要使用ThreadPoolExecutor,我通常会这样做:

            //创建一个核心线程数为4的线程池
            ExecutorService es = Executors.newFixedThreadPool(4);
            Task t = new Task();
            for (int i = 0; i < 100; i++) {
                es.submit(t);
            }
            es.shutdown();
    

    但是这里面发生了什么事,它的代码实现又是怎么一回事呢,我们来一探究竟。

    细究

    通过对submit方法打断点,我们可以发现,在AbstractExecutorService这个类里边半实现了submit方法

    //AbstractExecutorService#submit
    public Future<?> submit(Runnable task) {
            if (task == null) throw new NullPointerException();
            RunnableFuture<Void> ftask = newTaskFor(task, null);
            execute(ftask);//mark here
            return ftask;
    }
    

    为什么我说是“半实现”呢,因为在我mark的那行代码的execute(Runnable)方法仍然是一个抽象方法,在ThreadPoolExecutor类中,提供了对它的具体实现。

    public void execute(Runnable command) {
            if (command == null)
                throw new NullPointerException();
    
    //拿到当前的work(或者说是Runnable)数量
            int c = ctl.get();
    //如果工作的线程小于核心线程数的话
            if (workerCountOf(c) < corePoolSize) {
    //addWorker()方法里面会创建Worker类和对应的线程。
                if (addWorker(command, true))
                    return;
                c = ctl.get();
            }
    //如果大于核心线程数,就把这个Runnable对象command加入阻塞队列中,
    //同时应该二次检查是否应该创建新的线程,
    //如果线程池shutdown,就执行reject操作,就是拒绝服务了。
            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);
            }
    //如果无法加入阻塞队列,直接拒绝服务
            else if (!addWorker(command, false))
                reject(command);
     }
    

    再来看一下addWorker方法。

    private boolean addWorker(Runnable firstTask, boolean core) {
            retry:
            for (;;) {
                int c = ctl.get();
                int rs = runStateOf(c);
    
                // Check if queue empty only if necessary.
                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;
    //用CAS操作成功增加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();
                            workers.add(w);
                            int s = workers.size();
                            if (s > largestPoolSize)
                                largestPoolSize = s;
    //执行到这里,Worker就算是创建成功了
                            workerAdded = true;
                        }
                    } finally {
                        mainLock.unlock();
                    }
                    if (workerAdded) {
    //成功创建Worker之后,启动线程。
                        t.start();
                        workerStarted = true;
                    }
                }
            } finally {
                if (! workerStarted)
                    addWorkerFailed(w);
            }
            return workerStarted;
    }
    

    那这个Worker类到底是一个怎么样的数据结构呢,再来看一下。

    Worker类
    当我们创建一个Worker的时候,就把我们通过submit方法传递进来的Runnable给了firstTask属性,然后再通过工厂方法创建一个线程。同时Worker又是一个Runnable对象,在重写的run()方法中,调用了外部的runWorker(Worker)方法。
    正如上文所讲的一样,创建了线程就会start(),每个线程所做的就是这里的run方法,再细化,就是runWorker(Worker)方法 runWorker方法

    首先,把传递进来的Worker的Runnable对象给task,这时候的task局部对象有两种的取值,一种是我们直接submit进来的Runnable对象,另一种是null,出现null的情况是:当前线程的数量大于等于核心线程数量。
    所以,在while循环的时候,我们才会用task != null || (task = getTask() != null)这种表示,getTask方法待会再看,它会在阻塞队列中获取Runnable对象。
    拿到了task,就可以调用run方法了,因为我们现在就是在工作的线程里面。

    最后,来看看getTask()方法。

    最后的getTask()方法

    getTask方法的外部包着一个死循环for(;;),这是因为poll方法在阻塞队列空的时候并不会把当前线程阻塞住,它还会往下走。
    但是如果boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;这条语句不成立,timed为false,就可以成功的将线程阻塞住,我找遍了ThreadPoolExecutor这个类,都没有找到allowCoreThreadTimeOut这个属性的赋值的地方,那么就默认成立false,所以,在阻塞队列拿Runnable对象就主要是take()方法了。

    结尾

    正是这样不停向阻塞队列拿Runnable或者创建规定数量的线程执行Runnable的机制,保证了线程池的正常运行,当然我今天记录下来的只是冰山一角,这里面还是有很多地方值得我们去研究,比如AQS类,CAS机制等等。才疏学浅,只敢写下这些了。

    相关文章

      网友评论

        本文标题:ThreadPoolExecutor内部机制

        本文链接:https://www.haomeiwen.com/subject/sypaittx.html