ThreadPool底层原理

ThreadPool底层原理

• 线程池的好处:

实现线程的复用,Java1.5中引入的Executor框架把任务的提交和执行进行解耦，只需要定义好任务，然后提交给线程池，而不用关心该任务是如何执行、被哪个线程执行，以及什么时候执行。

• 线程池各个参数介绍

  • corePoolSize

    线程池中的核心线程数,当提交一个任务时,线程池创建一个新线程执行任务,直到当前线程数等于corePoolSize,如果当前线程数为corePoolSize,继续提交的任务被保存到阻塞队列中,等待被执行,如果执行了线程池ThreadPoolExecutor的prestartAllCoreThreads()方法,线程池会提前创建并启动所有核心线程
        /**
         * Starts all core threads, causing them to idly wait for work. This
         * overrides the default policy of starting core threads only when
         * new tasks are executed.
         *
         * @return the number of threads started
         */
        public int prestartAllCoreThreads() {
            int n = 0;
            while (addWorker(null, true))
                ++n;
            return n;
        }
    

  • maximunPoolSize

    线程池中允许的最大线程数,如果当前阻塞队列满了,且继续提交任务,则创建新的线程执行任务,前提是当前线程数小于maximunPoolSize
    

  • keepAliveTime

    线程空闲时的存活时间,即当线程没有任务执行时,继续存活的时间;默认的情况,这参数只在线程数大于corePoolSize时才有用
    

  • unit

    keepAliveTime的单位
    

  • workQueue

    用来保存等待被执行的任务阻塞队列,且任务必须实现Runnable接口,在JDK中提供如下阻塞队列
    1.ArrayBlockingQueue:基于数据的有界阻塞队列,按FIFO排序任务
    2.LinkedBlockingQueue:基于链表结构的阻塞队列,按FIFO排序任务,吞吐量通常要高于ArrayBlockingQueue
    3.SynChronousQueue:一个不存储元素的阻塞队列,每个插入插入操作必须等到另一个线程调用移除操作,否则插入操作一直处于阻塞状态,吞吐量通常要高于LinkedBlockingQueue
    4.priorityBlockingQueue:具有优先级的无界阻塞队列
    

  • threadFactory

    创建线程的工厂,通过自定义的线程工厂可以给每个新建的线程设置一个具有识别度的线程名
    

    

  • handler

    线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了4种策略：
    1、AbortPolicy：直接抛出异常，默认策略；
    2、CallerRunsPolicy：用调用者所在的线程来执行任务；
    3、DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
    4、DiscardPolicy：直接丢弃任务；
    当然也可以根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务
    

  • Executors

    Exectors工厂类提供了线程池的初始化接口，主要有如下几种：

    • newFixedThreadPool

      

      初始化一个指定线程数的线程池，其中corePoolSize == maximumPoolSize，使用LinkedBlockingQuene作为阻塞队列，不过当线程池没有可执行任务时，也不会释放线程。
      

    • newCachedThreadPool

      

      1、初始化一个可以缓存线程的线程池，默认缓存60s，线程池的线程数可达到Integer.MAX_VALUE，即2147483647，内部使用SynchronousQueue作为阻塞队列
      2、和newFixedThreadPool创建的线程池不同，newCachedThreadPool在没有任务执行时，当线程的空闲时间超过keepAliveTime，会自动释放线程资源，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；
      所以，使用该线程池时，一定要注意控制并发的任务数，否则创建大量的线程可能导致严重的性能问题。
      

    • newSingleThreadExecutor

      

      初始化的线程池中只有一个线程，如果该线程异常结束，会重新创建一个新的线程继续执行任务，唯一的线程可以保证所提交任务的顺序执行，内部使用LinkedBlockingQueue作为阻塞队列。
      

    • newScheduledThreadPool

      

      初始化的线程池可以在指定的时间内周期性的执行所提交的任务，在实际的业务场景中可以使用该线程池定期的同步数据
      

  • 线程池源码剖析

    除了newScheduledThreadPool,其他线程池都基于ThreadPoolExecutor类实现

    • 线程池内部的状态

      

      1.AtomicInteger是一个控制可信,高3位表示线程池的运行状态,低29位表示线程池中的线程数
      
      2.RUNNING:-1 <<COUNT_BITS，结果是11100000000000000000000000000000,高3位为111，该状态的线程池会接收新任务，并处理阻塞队列中的任务；
      
      3.SHUTDOWN:0 << COUNT_BITS,结果是00000000000000000000000000000000，高3位为000,该状态的线程池不会接收新任务,但会处理队列中的任务
      
      4.STOP:1 <<COUNT_BITS,结果是00100000000000000000000000000000,高3位是001,该状态线程不会接收新任务,也不会处理阻塞队列中的任务,而且会中断正在运行的任务
      
      5.TIDYING: 2<<COUNT_BITS，结果是01000000000000000000000000000000,高三位是010,当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现，当线程池在SHUTDOWN状态下，
      （1）阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING，
      （2）当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING
      
      6.TERMINATED:3<<COUNT_BITS，01100000000000000000000000000000，高三位是011，线程池彻底终止，就变成TERMINATED状态。线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。
      
      

    • 从execute实现观察提交流程

      

      1.workerCountOf()根据ctl低29位获取线程池线程数,如果线程数小于coolPoolSize，执行addWorker创建新的线程执行任务,否则执行步骤2

      2.如果线程池处于RUNNING状态，且把提交的任务成功放入阻塞队列中，则执行步骤（3），否则执行步骤（4）；

      3.再次检查线程池的状态，如果线程池没有RUNNING，且成功从阻塞队列中删除任务，则执行reject方法处理任务；

      • 下面的else if(workerCountOf(recheck)) == 0很关键,就是说当当前的运行的线程数为0，才会再去创建一个新线程

      4.addWorker创建新的线程执行任务不成功则执行reject方法

    • addWorker实现

      addWorking主要负责创建新的线程去执行任务
      

      (1)首先是判断线程池状态,如果线程池状态值大于或等于SHUTDOWN并且状态不为SHUTDOWN,任务为非空,队列是空，则不处理提交的任务,直接返回

      (2)通过参数core判断当前需要创建的线程是否为核心线程,如果core为true,且当前线程数小于corePoolsize,性质cas增加线程数,并跳出循环

      

      3.接着跳出循环后走到上图的创建线程逻辑,线程池工作线程是通过Worker类实现的,继承于Runnable，new Worker()时将当前的Runnable实例放入，再获取Worker实例的thread实际执行的t.start()就是执行Worker的重写的run方法

      

      4.worker的类的设计如下

      • 继承AQS
      • 实现Runnable接口
      • 将当前提交任务作为参数传入worker构造方法
      • 从Woker类的构造方法实现可以发现：线程工厂在创建线程thread时，将Woker实例本身this作为参数传入，当执行start方法启动线程thread时，本质是执行了Worker的runWorker方法。

    • runWorker方法的实现

      

      1、线程启动之后，通过unlock方法释放锁，设置AQS的state为0，表示可中断
      2、获取第一个任务firstTask，执行任务的run方法，不过在执行任务之前，会进行加锁操作，任务执行完会释放锁；
      3、在执行任务的前后，可以根据业务场景自定义beforeExecute和afterExecute方法；
      4、firstTask执行完成之后，通过getTask方法从阻塞队列中获取等待的任务，如果队列中没有任务，getTask方法会被阻塞并挂起，不会占用cpu资源；

    • getTask实现

      

      关键点在于红框部分

      1、workQueue.take：如果阻塞队列为空，当前线程会被挂起等待；当队列中有任务加入时，线程被唤醒，take方法返回任务，并执行；
      2、workQueue.poll：如果在keepAliveTime时间内，阻塞队列还是没有任务，则返回null；