ThreadPoolExecutor线程池工作原理解读

一，前言

在Android开发中，由于主线程要负责屏幕的刷新，UI的绘制，四大组件的管理，所以一些耗时操作不允许放在主线程中执行，，例如RxJava，Glide这些开源框架的底层原理都离不开线程池的加持，所以作为线程池的原理还是有必要了解一下的，线程池的作用就是管理和减少线程频繁的创建以及销毁

二，直接启动线程的弊端

对于一些初级的开发者来说，比较喜欢直接通过new Thread()来启动一个线程来执行业务代码，别问我为什么知道，因为我刚出来那会也这样玩，还导致了内存泄漏，那会是在做一个每隔30秒拉取股票指数的需求，那会不太熟练RxJava，脑子一道灵光，直接new了两个Thread再通过Handler发送定时消息去启动这两个Thread，结果很是悲惨，退出页面那一刻直接内存泄漏了，所以这种方式是有弊端的，日常开发中不要直接new Thread()了，弊端如下：

1，相信很多人只学过start()来启动线程，没几个知道怎么暂停，销毁线程，所以这种方式不方便管理线程

2，假设我们有一万张图片需要上传到服务器，单线程肯定是不行的这个时候肯定需要使用多线程来实现，我们的需求量是无限的，但系统给我们分配的资源是有限的，我尝试过一次性启动18个线程去做异步任务，结果OOM了，频繁的创建和销毁线程是很耗系统资源的

3，用过RxJava的伙伴都知道RxJava会有内存泄漏的风险，那么为什么会出现内存泄漏的问题呢，假设我们请求服务器数据，网络请求还没结束我们就关闭了页面，那么匿名内部类会隐式持有宿主的引用，这时就会导致内存得不到释放，然后就OOM了

三，线程池用法介绍

1，new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue)

这种方式日常开发中用的比较多，完全自定义属于自己的线程池，corePoolSize核心线程数，maximumPoolSize线程池最大线程数，keepAliveTime非核心线程存活事件，unit时间单位，workQueue任务队列存放我们的Runnable

2，Executors.newFixedThreadPool(nThreads)

这种方式创建的是固定核心线程数的线程池，没有非核心线程池，nThreads核心线程数量

3，Executors.newCachedThreadPool()

这种方式创建的线程池没有核心线程，插入任务到任务队列那一刻会进行阻塞，直到有线程取出这个任务，当线程取出任务的时候取不到元素，也会进行阻塞，直到有线程插入任务，空闲线程存活时间60秒

4，Executors.newScheduledThreadPool(corePoolSize)

这种方式创建的线程池比较适合处理一些定时任务，好比进入页面5秒后请求数据，corePoolSize核心线程数量，非核心线程执行完任务立即销毁

5，Executors.newSingleThreadExecutor()

这种方式创建的线程池是单例线程池，最大线程数以及核心线程数都是1，比较适合有顺序的逐个执行任务的业务场景，好比：先获取用户id —> 再获取用户信息

四，工作原理分析

1，execute()

public class ThreadPoolExecutor {

    public void execute(Runnable command) {
        //1，非空判断
        if (command == null)
            throw new NullPointerException();
        //2，当前当前线程池运行的线程数
        int c = ctl.get();
        
        //3，判断当前线程池运行的线程数量 < 核心线程数
        if (workerCountOf(c) < corePoolSize) {
            //4，添加核心线程
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        
        //5，走到这步代表当前线程池运行的线程数 >= 核心线程数，把任务放到任务队列
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();

            //6，判断线程池是否已经关闭 从任务队列中移除任务
            if (! isRunning(recheck) && remove(command))
                //7，执行拒绝策略
                reject(command);

            //8，判断线程池是否为空，一些特殊的线城池会有这种情况，比如CachedThreadPool线程池
            else if (workerCountOf(recheck) == 0)
                //9，添加非核心线程
                addWorker(null, false);
        }

        //10，判断添加任务是否失败
        else if (!addWorker(command, false))
            //11，执行拒绝策略
            reject(command);
    }

}

1，当我们提交一个任务时会获取当前线程运行的线程数量跟核心线程数量进行比对，如果当前运行的线程数量小于核心线程数量，那么就启动一个核心线程并直接执行任务，结束方法

2，否则就代表当前线程运行的线程数量已经>=核心线程数量，那么就把我们提交的任务放到任务队列里，

3，判读当前线程池是否已经关闭，如果关闭了就需要移除我们提交的任务，并且执行拒绝策略

4，判断线程池是否为空，为空就添加非核心线程，这里为什么要这样做呢？ 我理解的是兼容没有核心线程的线程池，例如CachedThreadPool就没有核心线程，如果此时不添加一条非核心线程，那么我们提交的任务是没法执行的

5，为什么addWorker()的Runnable传null呢？因为之前我们已经把任务存放到任务队列了，如果此时再把我们提交的任务传进去，就重复绑定了

2，addWorker()

public class ThreadPoolExecutor {

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            //1，如果当前线程池状态不允许创建线程，返回false
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
            
            //2，循环尝试获取创建线程的机会
            for (;;) {
                //3，获取线程池中的线程数量
                int wc = workerCountOf(c);
                //4，如果线程池中的线程数量大于等于最大数量 大于等于核心数量 返回false 
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //5，尝试添加线程数，成功了就跳出循环
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                //6，线程池状态发生改变，回到起点重来
                if (runStateOf(c) != rs)
                    continue retry;
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            //7，创建新任务
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                //8，加锁
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    //9，获取线程池状态
                    int rs = runStateOf(ctl.get());
                    
                    //10，如果线程池状态处于SHUTDOWN STOP TIDYING或者线程池状态处于SHUTDOWN且当前任务为null
                    //    则判断线程活着就抛出异常 否则将封装好的Worker添加到workers中
                    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 {
                    //11，释放锁
                    mainLock.unlock();
                }
                //12，添加成功启动线程，执行任务
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

}

1，当线程池调用addWorker()添加线程的时候会先判断当前线程池状态是否允许创建线程，不允许的话返回false结束方法，执行拒绝策略

2，死循环尝试创建线程，如果当前线程池的线程数量已满就返回false结束方法，执行拒绝策略，否则尝试创建线程，创建失败回到起点重试

3，以上两步都通过，把我们提交的任务，线程封装成Worker对象

4，开启锁，这里为什么要开锁呢？其实它锁起来的就两个东西，分别是workers以及largestPoolSize，这两个都是非线程安全的，如果多个线程并发访问就会有可能出现问题，所以需要加锁

5，如果当前线程池状态合法，将封装好的Worker添加到workers中，启动线程执行任务

3，Worker.thread.start()

private final class Worker implements Runnable {
        public void run() {
            runWorker(this);
        }

}

public class ThreadPoolExecutor {
    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        //获取绑定的任务
        Runnable task = w.firstTask;
        w.firstTask = null;
        //释放锁
        w.unlock();
        boolean completedAbruptly = true;
        try {
            //一直执行 如果task不为空 或者 从队列中获取的task不为空
            while (task != null || (task = getTask()) != null) {
                //加锁
                w.lock();
                //如果线程池状态为STOP 或 当前线程已中断需要中断线程
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        //执行我们提交的Runnable的run方法
                        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 {
            //将 worker 从数组 workers 里删除掉
            //
            processWorkerExit(w, completedAbruptly);
        }
    }
}

1，获取当前线程，获取线程绑定的任务，释放锁

2，循环判读当前线程绑定的任务不为空 或者 从任务队列中获取的任务不为空，其实这里就是线程池复用线程的核心一环

3，每执行完一个任务就把线程的完成任务数进行累加，释放锁

4，getTask()

public class ThreadPoolExecutor {

    private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?
        //这里是个死循环，核心线程复用的核心二环
        for (;;) {
            //获取线程池中当前线程数量
            int c = ctl.get();
            //获取线程池的状态
            int rs = runStateOf(c);
            //如果线程池的状态不是RUNNING状态 并且 任务队列为空的话就返回null
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            //获取线程数
            int wc = workerCountOf(c);

            //如果配置了allowCoreThreadTimeOut=true 或者 线程池中线程数大于核心线程数
            //这个timed用于控制线程获取阻塞队列中的任务时的等待时间
            //这个时间就是非核心线程的存活时长，keepAliveTime
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            
            //如果当前线程数大于线程池最大线程数 或者 线程已超时 返回null
            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();
                //如果获取到任务就把任务返回，执行任务的run方法
                //否则继续循环获取任务，注意此时timedOut为true，
                //如果是非核心线程或者配置了allowCoreThreadTimeOut=true的话下次循环就会返回null
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

}

1，获取当前线程数，线程池状态

2，如果线程池的状态不是RUNNING状态 并且 任务队列为空的话就返回null

3，判断是否配置了配置了allowCoreThreadTimeOut=true 或者 线程池中线程数大于核心线程数则timed为true，这时代表当前执行任务的线程是非核心线程或者是配置了超时时间的核心线程，不是一直存活在线程池的线程

4，从阻塞队列中获取任务，如果任务不为空的话就返回，负责继续循环获取任务，此时timedOut=true，如果是非核心线程或者配置了超时时间的核心线程再次循环都会返回null，如果是核心线程并且没有配置超时时间，这时就会不断的循环去取任务，完成线程复用的最重要的一环

5，也就是说线程池开启的核心线程，执行完任务都会循环从阻塞队列中取任务，取到就处理，取不到就死循环不断的去取