线程池ThreadPoolExecutor解析

线程池状态含义

RUNNING 接受新任务并且处理阻塞队列里的任务
SHUTDOWN :拒绝新任务但是处理阻 队列里的任务
STOP :拒绝新任务并且 抛弃阻塞队列 的任务 ,同时会中断正在处理的任务。
TIDYING 所有任务都执行完(包含阻 队列里面的任务)后当前线程池活动线程数为0 将要调用 terminated 方法
TERMINATED 终止状态, terminated 方法调用完成 以后的状态

线程池状态转换

RUNNING -> SHUTDOWN:由接收新任务变为拒绝新的任务,但是还是会处理阻塞队列里的任务 显式调用 shutdown方法 或者隐式调用了 finalize方法里面的 shutdown方法
RUNNING或 SHUTDOWN -> STOP :拒绝新任务并且抛弃阻塞队列并且终止正在执行的任务。显式调用 shutdownNow() 方法
SHUTDOWN->TIDYING 当线程池和任务队列都为空时;
STOP -> TIDYING 当线程池为空时
TIDY G -> TERM ATED terminated() hook 方法执行完成

线程池参数

corePoolSize :线程池 核心线程数
workQueue :用于保存等待执行的任务的阻塞队列,比如基于数组的有界
ArrayBlockingQueue 、基于链表的无界 LinkedBlockingQueu 、最多只有1个元素的同步队列 SynchronousQueue 及优先级队列 PriorityBlockingQueue等。
maximunPoolSize 线程池最大线程数量。
ThreadFactory :创建线程的工厂
RejectedExecutionHandler :饱和策略队列满并且线程个数达到 maximunPoolSize后采取 策略,
比如 AbortPolicy (抛出异常)
CallerRunsPolicy (使用调用者所在线程来运行务);
DiscardOldestPolicy (调用 poll 丢弃1个任务,执行当前任务)
DiscardPolicy (默默丢弃,不抛出异常)
keeyAliveTime :存活时间 如果当前线程池中的线程数量比核心线程数 ,并闲置状态, 则这些闲置的线程能存活的最大时间
TimeUnit: 存活时间的时间单位

线程池提交任务的 execute 方法

 public void execute(Runnable command) {
       //任务为空直接抛出异常
        if (command == null)
            throw new NullPointerException();
            //获取线程池状态和线程数
        int c = ctl.get();
        //当前线程池中线程个数是否小于corePoolSize ,小于则开启新线程运行任务
        if (workerCountOf(c) < corePoolSize) {
        //添加新的线程数,执行任务
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
		//如果线程池处于RUNNING状态,则添加任务到阻塞队列
        if (isRunning(c) && workQueue.offer(command)) {
        //再次检查
            int recheck = ctl.get();
            //如果状态不为RUNNING,从队列里删除该任务,执行拒绝策略
            if (! isRunning(recheck) && remove(command))
                reject(command);
               // 否则如果当前线程池为空则添加1个线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //如果队列满新增线程
        else if (!addWorker(command, false))
        //如果新增失败则执行拒绝策略
            reject(command);
    }

新增线程的 addWorkd()方法

:第一部分双重循环的目的是通过 CAS 操作增加线程数:
第二部分主要是把并发安全的任务 加到 workers 里面,并且启动任务执行

    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (int c = ctl.get();;) {
            // 检查队列是否只在必要时为空.
            if (runStateAtLeast(c, SHUTDOWN)
                && (runStateAtLeast(c, STOP)
                    || firstTask != null
                    || workQueue.isEmpty()))
                return false;

           //循环CAS增加线程个数
            for (;;) {
                //如果线程个数超限则返回false
                if (workerCountOf(c)
                    >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                    return false;
                    //CAS增加线程个数 ,同时只有一个线程成功
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                // CAS 失败了,则看线程池状态是否变化了,变化则跳到外层循环重新尝试获取线程池
                //状态,否则内层循环重新CAS
                if (runStateAtLeast(c, SHUTDOWN))
                    continue retry;
            }
        }
        //到这里说明 CAS 添加线程成功了,开始添加worker 添加成功调用线程的start执行任务
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
        //创建worker
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
            //加独占锁,为了实现workers 同步,因为可能多个线程可能同时调用了线程池 execute
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // 在锁定时重新检查.
                    // 在ThreadFactory失败时退出
                    // 在获得锁之前关闭
                    int c = ctl.get();
                    if (isRunning(c) ||
                        (runStateLessThan(c, STOP) && firstTask == null)) {
                        if (t.getState() != Thread.State.NEW)
                            throw new IllegalThreadStateException();
                            //添加worker
                        workers.add(w);
                        workerAdded = true;
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                    }
                } finally {
                    mainLock.unlock();
                }
                //添加成功后则启动任务
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

新增线程后执行task任务调用 runWorker()方法
新增一个线程就会创建一个包装对象worker ;创建后 调用worker 的runWorker()方法来执行任务
该方法会while循环从阻塞队列里取task任务。getTask()方法会更具是核心线程还是非核心线程来执行不同的方法
核心线程执行workQueue.take()方法。该方法是当队列任务数 =0时执行contion.await()方法,该方法会时该线程一直等待;
非核心线程执行workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) 。该方法是当队列任务数=0时执行超时等待方法 contion.awaitNanos(nanos) ,在使线程等待我们创建的线程池时设置的非核心线程的时间后,非核心线程不再等待,方法返回,非核心线程执行完毕结束销毁。

 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 不为空,直接进入循环。当线程执行完该任务后task==null 然后执行getTask()方法从阻塞队列里获取task
           */
            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 {
                    //执行任务的run方法 走getTask()
                        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保证下次还从阻塞队列的里取
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

//从阻塞队列获取任务
    private Runnable getTask() {
    //省略一些代码
     Runnable r = timed ?
      workQueue.poll(keepAliveTime, TimeUnit.NANOSE CONDS)  //非核心线程执行poll方法,执行超时等待,保证无任务后销毁
       :workQueue.take();                                   //核心线程执行take方法,一直等待保证核心线程不会销毁
     }
     
     //非核心线程的poll方法
    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0) {
                if (nanos <= 0)
                    return null;
                nanos = notEmpty.awaitNanos(nanos);   //执行超时等待,超时时间过后re
            }
            return dequeue();                         //任务不为空 返回任务
        } finally {
            lock.unlock();
        }
    }
    //核心线程的take方法
     public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();//一直等待
            return dequeue();    //任务不为空 返回任务
        } finally {
            lock.unlock();
        }
    }



     

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值