Java8 线程池解析

最新推荐文章于 2024-04-23 22:36:04 发布

Coder_Joker

最新推荐文章于 2024-04-23 22:36:04 发布

阅读量766

点赞数 1

分类专栏：基础多线程文章标签：线程池

基础同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

多线程

2 篇文章 0 订阅

订阅专栏

先看下常规的类的层次结构
: 在这里插入图片描述

2018-10-23 更:
今天再看这篇文章的时候,发现好像ctl这个变量不是很理解,因而从先去看了下源码,现针对 ctl单独抽出一块吧,线程池中的一些变量:


        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);
        }
        else if (!addWorker(command, false))
            reject(command);

从execute方法中,我们能发现ctl发挥了2个作用,第一个作用,就是workerCountOf:获取当前工作线程数以及isRunning判断运行状态,1个值却起了2个作用,具体是如何实现的

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;//i32-3=29
private static final int CAPACITY = (1 << COUNT_BITS) - 1; //最大容量为2^29 -1,用2进制表示就是000111…

// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS;  2进制为101..
private static final int SHUTDOWN   =  0 << COUNT_BITS; 000...
private static final int STOP       =  1 << COUNT_BITS;   running 与stop相反 001..
private static final int TIDYING    =  2 << COUNT_BITS; 是stop的2倍  010...
private static final int TERMINATED =  3 << COUNT_BITS;是stop的三倍 011...

// Packing and unpacking ctl
private static int runStateOf(int c)     { return c & ~CAPACITY; }  容量取反得到的是111000000.... 可以得知线程池采用高3位作为状态,因而高三位的变化并不会影响容量,容量的变化也不会影响状态的变化
private static int workerCountOf(int c)  { return c & CAPACITY; } 判断有无与运算,引申一点删除则用的是与+取反,添加则直接或即可
private static int ctlOf(int rs, int wc) { return rs | wc; }

不得不说位运算符真的很屌啊,希望自己以后也能经常往这方面想

 private final BlockingQueue<Runnable> workQueue; //存放工作线程
  private final ReentrantLock mainLock = new ReentrantLock(); //线程池的主要状态锁，对线程池状态（比如线程池大小
                                                            										  //、runState等）的改变都要使用这个锁
  private final HashSet<Worker> workers = new HashSet<Worker>();

ThreadPoolExecutor中构造函数的各个参数:

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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

CorePoolSize:活动线程的最大值(当当前线程数目小于corePoolSize的时候,每来一个task就会添加一个线程,若超过了则会放入到缓存队列中)
MaxMinumPoolSize:线程数目的最大值
KeepAliveTime:线程的存活时间,默认情况下是当线程数目大于corePoolSize的时候才会去计算这个时间(是个TimeUnit类型)
workQueue:是一个缓存队列,当超过corePoolSize之后task会将任务放在这里
ThreadFactory:线程工厂
RejectedExecutionHandler:拒绝策略,当无法添加task的时候回执行拒绝策略

关于线程池的状态: 至于为什么是这些数字,本人对位运算处于不了解状态,哎,这是头疼,虽然B格很高
()RUNNING :-536 870 912 是唯一小于0的

(由RUNNING->SHUTDOWN)SHUTDOWN:**0**	(不接收新的任务,但能处理当前存在的任务)

(RUNNGIN||SHUTDOWN->STOP)STOP:**56870192**(不接收任务也不处理任务,同时中断正在执行的任务)

(SHUTDOWN->TIDYING:线程数为0,并且workerQueue的size也为0 ;STOP->TIDYING:线程数为0)TIDYING: **1073741824** 当执行terminated()之后状态就会变为TERMINATED状态

TERMINATED:**160612736**

所以大小方面的话:RUNNING<SHUTDOWN<STOP<TIDYING<TERMINATED

关于队列常见的2种:SynchronousQueue:没有容量的阻塞队列,一次插入等待一次获取(时序性要求高)
LinkedBlockingQueue 无界阻塞队列这个阻塞队列用于不会满

Executors是线程池的包装类:提供了如下几种创建线程池的方法:

//创建的是corePoolSize为nThreads的线程池,并且最大值也是nThreads,存活时间是0s,工作队列采用的是无界阻塞队列
  public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
  
 //创建的是缓存线程池,什么意思呢,就是当需要的时候创建线程,同时呢也可能会复用还存活着的线程,这个缓存线程池适合用于短暂生命周期的task
     public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    //创建一个定时执行任务的线程池
   public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

execute流程:
在这里插入图片描述
task会被一个新的线程或者是之前存活着的线程所消费
如果该task不能被消费,则可能是线程池不处于运行状态,或者容量达到了上限
具体的execute方法:
执行的步骤为
1:当前线程数<corePoolSize则直接创建线程执行消费
2.缓存队列如果还没达到临界值则添加到缓存队列否则下一步判断
3.如果线程数目处于(corePoolSize,maxmunPoolSize)范围内,则创建线程执行
4.否则执行拒绝策略

 	int c = ctl.get();
 		//如果当前工作线程数目小于corePoolSize则直接创建线程执行消费这个task
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //如果线程池处于运行状态,并且在缓存队列中添加成功,
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //进行二次校验状态,如果不处于运行状态则移除这个task并且执行拒绝策略
            if (! isRunning(recheck) && remove(command))
                reject(command);
                //如果当前线程运行数为0,则创建新的线程
                //这里为什么会是null,是因为else 的条件,上步的if没有执行表明线程处于运行状态或者remove失败,意味着workQueue中已经有这个command了,所以null即可,不能重复添加
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //线程不处于运行状态,或者添加task失败,则尝试新建线程处理
        else if (!addWorker(command, false))
            reject(command);

addWorker(Runnable firstTask,boolean b)代码解释:
addWorker的流程可以这么理解:
1.判断状态,如果状态是不是RUNNING,或者无效任务(缓存队列为空,然后添加了一个null任务)直接返回
2.配合cas尝试添加工作线程数目
3.全局锁lock,然后添加线程,失败则直接回滚

这个core参数若为true则使用corePoolSize,否则使用maximumPoolSize
  private boolean addWorker(Runnable firstTask, boolean core) {
  	//定义一个外层循环
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
			
            //判断当前状态,如果状态是terminated或者stop状态,或者(任务为空并且缓存队列为空)则直接返回,任务任务队列都为空了还添加啥线程
            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;//cas更改工作线程数目
                c = ctl.get();  // Re-read ctl
                //说明更新失败了,则需要重新检测状态是否改变
                //状态改变了则需要去外层循环,重新开始
                if (runStateOf(c) != rs)
                    continue retry;
                    //状态没改变但是失败了,则一直重新尝试修改工作线程数
            }
        }

        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());
					//如果线程池小于SHUTDOWN(意味着处于RUNNING状态)或者是(处于SHUTDOWN状态的同时新增的task为空)
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // 如果线程活着,说明已经执行了,本应该刚创建的线程是还未start的,则抛出异常
                            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;
    }

添加任务失败的源码:
字面就能看得懂

    private void addWorkerFailed(Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (w != null)
                workers.remove(w);
            decrementWorkerCount();
            tryTerminate();
        } finally {
            mainLock.unlock();
        }
    }

至此,添加工作线程就结束了,但是工作线程start了,但是既然是线程池肯定是会复用,复用代码肯定不是我们自个儿写的,所以,have a look
核心代码是Worer#runWorker(Woker w)

这个步骤摘自这里 https://www.imooc.com/article/34071
**1.从worker 的firstTask 开始执行，随着线程的运行，worker不停的执行getTask() 获取任务，如果拿不到任务，就会根据线程的池配置信息来决定是否让 worker退出。如果worker执行过程中抛出异常,会导致worker退出，并试图创建一个新的线程替代当前worker。
2.执行任务之前，获取锁确保任务执行不被其他线程干扰。如果不是STOP状态，worker线程需要清除中断标记。 3.处理每个任务之前都要执行钩子函数 beforeExecute(),如果钩子函数抛出异常那么也会出发worker 过早的退出，并尝试创建一个新的worker 替代它。
4.假如执行beforeExecute()顺利,接下来就是执行任务了。如果执行中出现异常，那么就会捕获这些异常，进行包装成 runtimeException 和 error,Throwable也被包装成 Error的因为Ruunabl.run 不能抛出Throwabl 异常。最后把这些异常和 worker 发给 afterExecute()处理。
5.任务执行完成后，执行afterExecute(),也可能会产生异常，任何的异常都会导致worker 销毁。
**

  final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        //清空firstTask,workeQueue中就可以获取下一个task了
        w.firstTask = null;
        w.unlock(); // allow interrupts :为啥会unlock就会允许中断呢,这里借用下他人的看法:   因为在worker构建实列时。worker的state 属性被设置为-1,在调用池shutDownNow()函数分别对worker进行终止时,会判断worker 的 state >= 0 ,如果不符合 就不会终止。 
        boolean completedAbruptly = true;//是否允许突然完成,啥意思呢,就是说线程挂了,是否允许算这次任务是消费完毕的
        try {
        //不停的获取task
            while (task != null || (task = getTask()) != null) {
                w.lock();//锁住这个工作线程,别被其他线程所使用
                // If pool is stopping, ensure thread is interrupted;	如果线程池处于STOP状态,则终止这个线程
                // if not, ensure thread is not interrupted.  This	如果不处于STOP状态,则确保这个线程不被终止
                // 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(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(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

Coder_Joker

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java8 线程池解析

先看下常规的类的层次结构:ThreadPoolExecutor中构造函数的各个参数:public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, ...
复制链接

扫一扫