ThreadPoolExecutor 解析

最新推荐文章于 2024-06-20 20:46:49 发布

Pure_Eyes

最新推荐文章于 2024-06-20 20:46:49 发布

阅读量199

点赞数

本文链接：https://blog.csdn.net/Pure_Eyes/article/details/100043991

版权

并发通常需要线程池来支撑，否则直接频繁创建线程会迅速耗尽系统资源。
jdk预先自定义了几种线程池：比如缓存线程池、固定线程池、延迟线程池、单线程池，这些直接利用java
的 Executors的静态方法就可直接获取到。
虽然Executos创建线程池简单方便，但生产环境不管简单只管稳定，这些线程池其实都是直接调用ThreadPoolExecutor的构造函数返回了一个对象，只是提供的参数不同，最多延迟线程池与单线程池进行了简单的包装
我们先来研究ThreadPoolExecutor是怎么实现线程池的，分析源码：
线程池的主要结构：1、任务队列；2、工作线程；3、线程数目控制规则；4、任务拒绝策略
ThreadPoolExecutor对这些结构的支撑为：BlockingQueue充当任务队列，内部的Worker类作为工作线程，每个woker对象都含有一个线程，RejectedExecutionHandler接口属于拒绝策略接口，ThreadPoolExecutor已经提供了4个策略类，下面会介绍

类的成员变量

	//记录线程池状态和线程数量（总共32位，前三位表示线程池状态，后29位表示线程数量），对象创建成功就是运行中状态
	private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    //线程数量统计位数29  Integer.SIZE=32 , 大约5亿，现在计算机好像还一次性开不了5亿个线程，足够用了
    private static final int COUNT_BITS = Integer.SIZE - 3;
    //容量 000 11111111111111111111111111111
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    //运行中 111 00000000000000000000000000000
    private static final int RUNNING    = -1 << COUNT_BITS;
    //关闭 000 00000000000000000000000000000
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    //停止 001 00000000000000000000000000000
    private static final int STOP       =  1 << COUNT_BITS;
    //整理 010 00000000000000000000000000000
    private static final int TIDYING    =  2 << COUNT_BITS;
    //终止 011 00000000000000000000000000000
    private static final int TERMINATED =  3 << COUNT_BITS;

状态	解释
RUNNING	运行态，可处理新任务并执行队列中的任务，是线程池创建好后的默认状态
SHUTDOW	关闭态，不接受新任务，但处理队列中的任务
STOP	停止态，不接受新任务，不处理队列中任务，且打断运行中任务
TIDYING	整理态，所有任务已经结束，workerCount = 0 ，将执行terminated()方法
TERMINATED	结束态，terminated() 方法已完成

构造方法

再看看构造方法,总共4个(这里只探究jdk7，8以上暂不介绍)

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }
    
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

代码中可以看出其中3个构造方法内部都是调用的第4个参数最全的构造方法，

corePoolSize 核心线程数，提交任务时，线程总数没达到这个值时不会利用已有的，而是直接创建新线程并把任务交给它
maximumPoolSize 最大线程数当线程总数超过这个值时会进行一个死循环不断尝试获取新任务，超时了就跳出循环死掉
keepAliveTime 线程数超过corePoolSize 后开始有用武之地了，在死循环时，等待时间超出这个值就杀死这个线程
TimeUnit unit 超时单位
workQueue 任务队列，是一个阻塞队列
threadFactory 线程工厂创建Thread对象主要是设置线程的名称便于跟踪
handler 拒绝策略线程池也有力有不逮的时候，比如说任务队列已经满了，此时不能再入队了，需要策略来处理这个任务

线程池创建好了，此时我们发现代码中现在只是初始化了一下变量，没有其他动作，线程池起码得先有线程啊，不急。
ThreadPoolExecutor初始状态下是不会创建线程的，线程是在任务提交的过程中一个个创建的，不是批量创建的

提交任务

ThreadPoolExecutor的提交任务主要有3种

    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

处理任务(执行前)

可以看到这3种方法最终调用的都是execute方法，execute方法的参数是一个Runnable接口，而这3个方法对入参都进行了一下包装，最终返回了一个Future对象用以跟踪任务执行情况。当然我们也可以直接用execute方法来提交任务，但与无论是语义理解上还是程序扩展上submit都更好一些
Future对象的探究放到后面，我们先来看下execute是如何交付任务的

 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();
        }
        //上一步中 线程数已达到核心配置或者是增加线程失败  此时要尝试进入等待队列中 等待处理
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //若是入队成功需要再检查一下线程池状态， 不在运行状态时要把任务移出队列 并执行拒绝策略
            if (! isRunning(recheck) && remove(command))
                reject(command);
              // 入队成功并且线程池状态正常  此时可能没有线程池来处理了   要加一个新线程进去
              // 即使由于并行原因判断失误  判断为0后在增加新线程前 其他调用线程也执行到了这里也加了一个新线程进去  也没关系
              // 多加几个新线程没什么影响  多出的线程空转自己玩一会会自己进入火葬场的   在这里我们只需要保证线程数不能少即可  宁可信其无  不可信其有
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //第一步尝试加新线程没成功   第二步尝试入队也没成功  任务成了没人要的孩子   需要找个备用保姆  交给预先定义的拒绝策略
        else if (!addWorker(command, false))
            reject(command);
    }

execute逻辑可以总结为3步
第一步：尝试增加新线程处理新任务
第二步：不能增加线程或者是增加新线程失败了，再尝试进行押进等待队列中等待处理
第三步：一、二步都没成功处理掉任务，那么需要将任务打包一下拒绝掉

execute方法体代码量并不多，都是调用的其他方法：

ctl.get(）返回状态变量
workerCountOf() 获取当前工作线程总数
isRunning() 判断当前是否处于运行中状态
workQueue.offer(command) 任务入队
remove(command)
reject(command) 拒绝任务
addWorker(command, boolean) 添加新线程

我们不按照顺序一个个解释，先拿最简单的解释
前3个方法都是对线程池状态的判断，后面我会集中介绍，在此直接按照函数语义理解即可

第二步中调用offer方法入队，这不是个阻塞方法，成功了返回true 失败了返回false ，具体逻辑由BlockingQueue的实现类实现，主要利用了他们的线程安全性，与线程池的其他特性没啥关系，在此不做过多解释，有意者可以去看下他们的源码
任务出队时先调用了队列本身的remove方法，不多说，tryTerminate()放到后面关闭线程中时再说明

	public boolean remove(Runnable task) {
        boolean removed = workQueue.remove(task);
        tryTerminate(); // In case SHUTDOWN and now empty
        return removed;
    }

简单方法解释完再来看复杂的addWorker方法，它是一个异步执行任务核心方法
方法体中直接实现了

private boolean addWorker(Runnable firstTask, boolean core) {
		//（1）循环CAS操作，将线程池中的线程数+1. 这里不多见的使用了类似goto写法  便于跳出循环重复执行
        retry:      
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // 检查一下线程池状态关了没，实现SHUTDOWN 以及后面状态下不再接受新任务的特性
            //但若是此时仍然是SHUTDOWN 状态  并且新任务不是null 且工作队列不为空时仍可以添加线程
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                //判断线程数量是不是超了
                //线程数到达理论上限则加线程失败 
                // 根据core参数判断  core true   超过corePoolSize 退出  flase  超过maximumPoolSize退出
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                 //CAS修改clt的值+1，在线程池中为将要添加的线程流出空间，成功退出cas循环，失败继续
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                //若是发现线程池状态改变则再次尝试cas增加线程，一直等到状态恢复了外层循环检测到的状态
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }
		 //(2)新建线程，并加入到线程池workers中。
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            final ReentrantLock mainLock = this.mainLock;
            //加一个新工作线程对象，虽然firstTask有可能是空的
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int c = ctl.get();
                    int rs = runStateOf(c);
                    //线程池运行状态下  或者关闭状态下firstTask是空的 时才把线程加到工作组中
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        //线程是new出来的  还没启动 此时发现他启动了那就不正常了
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                         //加到工作组中
                        workers.add(w);
                        //largestPoolSize更新   由于此时加了全局锁  不用担心出现数据不一致
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
//                运行到这里代表上面线程加到工作组中成功了 此时启动线程
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
                //workerStarted为true代表线程启动指令也发出成功了 为false代表 start()方法出现了异常需要进入addWorkerFailed()方法中将刚加进去的线程移除掉
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }
     private void addWorkerFailed(Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            //移除掉线程并且工作数量恢复实际数字(cas减)
            if (w != null)
                workers.remove(w);
            decrementWorkerCount();
            tryTerminate();
        } finally {
            mainLock.unlock();
        }
    }

执行任务

任务交付完毕后线程也就启动成功，此时线程随机执行Work对象中的run()方法，里面调用了ThreadPoolExecutor的runWorker()方法，传入该work对象，runWorker方法中执行work对象中的Runnable对象的run方法，并在执行前后进行监控执行过程。
addWorker执行完毕后调用的submit方法也就即将返回了，后面的执行任务就是真正的异步了，这里将线程启动后，线程异步去拿任务的过程需要看下类Worker的源码，并不是很长

    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        private static final long serialVersionUID = 6138294804551838833L;

        /** Thread this worker is running in.  Null if factory fails. */
        final Thread thread;
        /** Initial task to run.  Possibly null. */
        Runnable firstTask;
        /** Per-thread task counter */
        volatile long completedTasks;

        /**
         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
         */
        Worker(Runnable firstTask) {
          //设置同步器的state
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        /** Delegates main run loop to outer runWorker  */
        public void run() {
        //runWorker方法是THrealPoolExecutor实现的
            runWorker(this);
        }

        // Lock methods
        //
        // The value 0 represents the unlocked state.
        // The value 1 represents the locked state.

        protected boolean isHeldExclusively() {
            return getState() != 0;
        }

        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        public void lock()        { acquire(1); }
        public boolean tryLock()  { return tryAcquire(1); }
        public void unlock()      { release(1); }
        public boolean isLocked() { return isHeldExclusively(); }

        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

Worker加到工作组中并且启动成功后 start的是里面的Thread ，而传给Thread构造参数的Runnable是它本身，因为其已经实现了Runnable接口，因此线程最终调用了Worker的run方法，run方法里面又调用了ThreadPoolExecutor的runWorker方法，

	final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        //先解锁一次  暂不知道为啥
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
        //若是设置了允许核心线程超时时间或者线程总数超过核心线程数，则getTask()方法里面调用的是阻塞队列的，poll(long timeout, TimeUnit unit)方法，否则会调用take方法
            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可自行扩展
                    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
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    //完成任务数加一  无论任务是否出现异常  在这里可发现若是任务运行失败了不会重新入队  即只会运行一次
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
          //清理线程  若是不允许核心线程超时并且核心线程数没有超配置 则及时任务队列空了 也会阻塞到getTask()方法处  不会运行到这里
            processWorkerExit(w, completedAbruptly);
        }
    }

清理线程

 private void processWorkerExit(Worker w, boolean completedAbruptly) {
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
        //	线程清理时才会统计完成的任务数  jdk应该是为了提高效率才会在这里归总完成任务数  正在运行的线程不会计入 
        // 并且阻塞的核心线程不会加到这里来  
            completedTaskCount += w.completedTasks;
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }
//      在对线程池有负效益的操作时，都需要“尝试终止”线程池
        tryTerminate();

        int c = ctl.get();
          //如果状态是running、shutdown，即tryTerminate()没有成功终止线程池，尝试再添加一个worker
        if (runStateLessThan(c, STOP)) {
        //不是突然完成的，即没有task任务可以获取而完成的，计算min，并根据当前worker数量判断是否需要addWorker()
            if (!completedAbruptly) {
             //allowCoreThreadTimeOut默认为false，即min默认为corePoolSize
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                //如果min为0，即不需要维持核心线程数量，且workQueue不为空，至少保持一个线程
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                     //如果线程数量大于最少数量，直接返回，否则下面至少要addWorker一个
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }
            addWorker(null, false);
        }
    }

Pure_Eyes

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ThreadPoolExecutor 解析

并发通常需要线程池来支撑，否则直接频繁创建线程会迅速耗尽系统资源。jdk预先自定义了几种线程池：比如缓存线程池、固定线程池、延迟线程池、单线程池，这些直接利用java的 Executors的静态方法就可直接获取到。虽然Executos创建线程池简单方便，但生产环境不管简单只管稳定，这些线程池其实都是直接调用ThreadPoolExecutor的构造函数返回了一个对象，只是提供的参数不同，最多...
复制链接

扫一扫