JUC:ThreadPoolExecutor

ThreadPoolExecutor

介绍

源码地址:java.util.concurrent.ThreadPoolExecutor
线程池意义:

  1. 减少开销:重复使用纤尘资源,降低创建和回收的效率。
  2. 便于管理:帮你维护线程ID,线程状态等信息。

源码

继承关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NXSWA6nP-1642494029647)(./image/t1.jpg)]

ThreadPoolExecutor继承了AbstractExectorService,AbstractExectorService实现了ExecutorService接口。ExecutorService接口继承了Executor接口。

静态变量

	private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

可以算出其状态的二进制表示为:

RUNNING:    11100000 00000000 00000000 00000000
SHUTDOWN:   00000000 00000000 00000000 00000000
STOP:       00100000 00000000 00000000 00000000
TIDYING:    01000000 00000000 00000000 00000000
TERMINATED: 01100000 00000000 00000000 00000000

五个状态只用到了高三位,低29位用于表示工作线程数,二者存储在一起是为了能够原子性的对二者进行改变。五种状态的含义为:

  • RUNNING:接受新任务,也能处理阻塞队列里的任务。
  • SHUTDOWN:不接受新任务,但是处理阻塞队列里的任务。
  • STOP:不接受新任务,不处理阻塞队列里的任务,中断处理过程中的任务。
  • TIDYING:当所有的任务都执行完了,当前线程池已经没有工作线程,这时线程池将对转化为TIDYING状态,并且将调用terminated方法。
  • TERMINATED:terminated方法调用完成。
    注意,由于ctl值是int类型的,所以RUNNING在这几个状态中是最小的。这是程序中快速对状态进行判断的一个技巧。
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JXV9gtg8-1642494029648)(./image/t2.jpg)]

属性

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static int ctlOf(int rs, int wc) { return rs | wc; }

ctl是一个重要的属性,他就是上文中,结合了线程池状态和池中工作线程数两个信息的变量。它初始化时调用了ctlOf方法,可以看到ctlOf只是一个或操作。RUNNING规定了高三位的线程状态,0代表工作线程数。下面看其他属性。

private final BlockingQueue<Runnable> workQueue;
private final ReentrantLock mainLock = new ReentrantLock();
private final HashSet<Worker> workers = new HashSet<Worker>();
private final Condition termination = mainLock.newCondition();
private int largestPoolSize;
private long completedTaskCount;
private volatile ThreadFactory threadFactory;
private volatile RejectedExecutionHandler handler;
private volatile long keepAliveTime;
private volatile boolean allowCoreThreadTimeOut;
private volatile int corePoolSize;
private volatile int maximumPoolSize;
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
private static final RuntimePermission shutdownPerm = new RuntimePermission("modifyThread");
private final AccessControlContext acc;

下面简单解释一下上面的属性:

  • workQueue
    类型为BlockQueue接口,用来存储挤压任务的阻塞队列。

blockQueue 作为线程容器、阻塞队列,多用于生产者、消费者的关系模式中,保障并发编程线程同步,线程池中被用于当作存储任务的队列,还可以保证线程执行的有序性。

这里详细讲一下Runnable,在实际使用中用户可以向ThreadPoolExecutor提交两种任务:Callable和Runnable。

  1. Callable
    该类任务有返回结果,可以抛出异常。
    通过submit函数提交,返回Future对象。
    可通过get获取执行结果。

  2. Runnable
    该类任务只执行,无法获取返回结果,并在执行过程中无法抛异常。
    通过execute提交。

继承关系如下:

在这里插入图片描述

这里可能就会有疑惑点为什么泛型是Runnable,Callable类型任务如何进入阻塞队列?
答:父类的AbstractExecutorService将会把Callable对象转化为Runable的子类FutureTask。

  • mainLock
    ReentrantLock类型,可以料想对线程池的一些操作需要状态同步,所以需要用到锁。
  • workers
    HashSet类型,泛型是内部类Worker。Worker这个内部类可以视为对工作线程及其一些状态的封装,workers是用来存储所有Worker的集合。
  • termination
    由mainLock创建的Condition,看变量名应该是用于terminal调用时的线程同步。
  • largestPoolSize
    线程池中最多有过多少活跃线程。
  • completedTaskCount
    线程池总共处理多少任务。
  • threadFactory
    类型为ThreadFactory接口,用户可以自定义创建工作线程的工厂。
  • handler
    拒绝策略,当workQueue满载时将会触发。
  • KeepAliveTime
    工作线程空闲时则保存存活时间。
  • allowCoreThreadTimeOut
    布尔类型,是否需要保持核心线程始终处于存活。
  • corePoolSize
    核心线程数,可以看作稳定的工作线程数量,当阻塞队列为满载时,线程池将保持核心线程数。
  • maximumPoolSize
    最大线程数。可以看作弹性的工作线程数量,当阻塞队列满载时,线程池将会在核心线程数的基础上创建新的线程来处理任务,直到最大线程数。
  • shutdownPerm
    运行时权限属性。
  • acc
    系统资源访问决策
    为了能更好的理解源码,简单的介绍一下运转规则:
    1)当池子大小小于corePoolSize就新建线程,并处理请求
    2)当池子大小等于corePoolSize,把请求放入workQueue中,池子里的空闲线程就去从workQueue中取任务并处理
    3)当workQueue放不下新入的任务时,新建线程入池,并处理请求,如果池子大小撑到了maximumPoolSize就用RejectedExecutionHandler来做拒绝处理
    4)另外,当池子的线程数大于corePoolSize的时候,多余的线程会等待keepAliveTime长的时间,如果无请求可处理就自行销毁

内部类

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        /**
         * This class will never be serialized, but we provide a
         * serialVersionUID to suppress a javac warning.
         */
        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) {
            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(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) {
                }
            }
        }
    }
  • 继承关系
    • 继承AQS:说明Worker内部存在同步需求。
    • 实现Runnable:Worker本身就是一个异步的任务调度者。
  • 方法
    了解过AQS的就知道都是老生常谈了。这里讲一下最重要的run方法。
final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        //unlock,表示当前 worker 线程允许中断,因为 new Worker 默认的 state=-1,此处是调用
        //Worker 类的 tryRelease()方法,将 state 置为 0,
        //而 interruptIfStarted()中只有 state>=0 才允许调用中断
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock(); //上锁,不是为了防止并发执行任务,为了在 shutdown()时不终止正在运行的 worker
                //线程池为 stop 状态时不接受新任务,不执行已经加入任务队列的任务,还中断正在执行的任务
                //所以对于 stop 状态以上是要中断线程的
                //(Thread.interrupted() &&runStateAtLeast(ctl.get(), STOP)确保线程中断标志位为 true 且是 stop 状态以上,接着清除了中断标志
                //!wt.isInterrupted()则再一次检查保证线程需要设置中断标志位
                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(); //执行任务中的 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,需要再通过 getTask()取) + 记录该 Worker 完成任务数量 + 解锁
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
            //1.将入参 worker 从数组 workers 里删除掉;
            //2.根据布尔值 allowCoreThreadTimeOut 来决定是否补充新的 Worker 进数组workers
        }
    }

逻辑也十分好理解。其调用了getTask()方法

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?
        for (;;) {//自旋
            int c = ctl.get();
            int rs = runStateOf(c);
            /* 对线程池状态的判断,两种情况会 workerCount-1,并且返回 null
            1. 线程池状态为 shutdown,且 workQueue 为空(反映了 shutdown 状态的线程池还是要执行 workQueue 中剩余的任务的)
            2. 线程池状态为 stop(shutdownNow()会导致变成 STOP)(此时不用考虑 workQueue的情况)*/
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {//在rs >= STOP时是不对拥塞队列进行操作的。当状态为shutdwon但workqueue不为空则不会执行下面语句
                decrementWorkerCount();
                return null;//返回 null,则当前 worker 线程会退出
            }
            int wc = workerCountOf(c);
            // timed 变量用于判断是否需要进行超时控制。
            // allowCoreThreadTimeOut 默认是 false,也就是核心线程不允许进行超时;
            // wc > corePoolSize,表示当前线程池中的线程数量大于核心线程数量;
            // 对于超过核心线程数量的这些线程,需要进行超时控制
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            /*1. 线程数量超过 maximumPoolSize 可能是线程池在运行时被调用了 setMaximumPoolSize()
            被改变了大小,否则已经 addWorker()成功不会超过 maximumPoolSize
            2. timed && timedOut 如果为 true,表示当前操作需要进行超时控制,并且上次从阻塞队列中获取任务发生了超时.其实就是体现了空闲线程的存活时间*/
            if ((wc > maximumPoolSize || (timed && timedOut))
                    && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
            try {
                /*根据 timed 来判断,如果为 true,则通过阻塞队列 poll 方法进行超时控制,如果在
                keepaliveTime 时间内没有获取到任务,则返回 null.
                否则通过 take 方法阻塞式获取队列中的任务*/
                Runnable r = timed ?
                        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                        workQueue.take();
                if (r != null)//如果拿到的任务不为空,则直接返回给 worker 进行处理
                    return r;
                timedOut = true;//如果 r==null,说明已经超时了,设置 timedOut=true,在下次自旋的时候进行回收
            } catch (InterruptedException retry) {
                timedOut = false;// 如果获取任务时当前线程发生了中断,则设置 timedOut 为false 并返回循环重试
            }
        }
    }

在这里解释一下BlockingQueue的基本操作
在这里插入图片描述

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);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
    	//addworker第二个参数用来指示添加的是否是核心线程任务
        else if (!addWorker(command, false))
            reject(command);
    }

具体流程为,

  • 查看任务是否为NULL,是则触发异常。
  • 若工作线程数<要求的核心线程数,执行添加核心线程addworker,更新c。
  • 若c中状态为正在运行,worlQueue.offer任务执行成功,再次检查线程池状态,
    • 若不为RUNNING则移除当前任务,并且触发拒绝策略。
    • 若线程池工作状态不为RUNNING或上面remove失败且线程工作数量==0则添加非核心线程任务。
  • 再次尝试添加非核心线程任务任务,若失败触发拒绝策略。
    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;
                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 {
            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;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

3-26:这段循环对当前线程池的一系列状态进行判断,值得注意的是19-23代码该代码将约束只有一个线程能够成功跳出循环,若cas失败则重新开始。既然只有一个线程能够执行后面操作那么为什么36行还进行了加锁,因为workers.add(w)操作是线程不安全的。

实际使用

第一次接触线程池的人不知道这些函数这么多是如何相互调用的。
首先在实际运用中会,实现Runable接口,初始化线程池,将BlockingQueue实现类的其中一种实例作为参数传入线程池的构造函数,在构造函数中会将其赋值给workQueue,将自定义或Executors.defaultThreadFactory()作为线程工厂和选定的拒绝策略传入线程池构造函数。对于每个用户自己构造的Runable实现类实例都执行pool.execute(实例)方法。execute调用addWorker,addWorker调用new Worker(),在Worker启动时自动调用run方法,run调用runWorker。这样我们就知道了runworker和execute这两个函数之间的调用链了。

参考

  1. java线程池ThreadPoolExecutor类使用详解
  2. ThreadPoolExecutor源码解析
  3. 源码级解读ThreadPoolExecutor,线程池问题将再也难不住你
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值