Java线程池实现原理

我的书包哪里去了

已于 2022-08-24 15:42:01 修改

阅读量444

点赞数

分类专栏： Java 文章标签： java线程池

于 2018-08-06 10:41:08 首次发布

本文链接：https://blog.csdn.net/qq_34490018/article/details/81449956

版权

Java 专栏收录该内容

17 篇文章 2 订阅

订阅专栏

文章目录

线程池简介

线程池核心类ThreadPoolExecutor

线程池的工厂类Executors

线程池的处理流程

线程池的五种状态

线程池提交任务的两种方式

线程池的关闭

线程池简介

多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程和销毁线程所需要的时间远远大于任务执行时间，那么会大大降低系统的效率。

因此在Java中可以通过使用线程池来解决这一问题。线程池技术正是关注如何缩短或调整创建线程和销毁线程所花的时间的技术，从而提高服务器程序性能的。它把创建线程和销毁线程所花的时间分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有创建线程和销毁线程所花的时间的开销了。

使用线程池的优点：

（1）线程是稀缺资源，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以重复使用。

（2）可以根据系统的承受能力，调整线程池中工作线程的数量，防止因为消耗过多内存导致服务器崩溃。

线程池核心类ThreadPoolExecutor

ThreadPoolExecutor类是线程池中最核心的一个类，其它线程池内部都是基于ThreadPoolExecutor类（Executor的子类）实现的。

在ThreadPoolExecutor类中提供了四个构造方法（其继承AbstractExecutorService类）：

    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);

各参数说明：

corePoolSize：核心线程数
maxPoolSize：最大线程数，它表示在线程池中最多创建多少个线程

（注：ThreadPoolExecutor提供了动态调整线程池容量大小的方法：setCorePoolSize()和setMaximumPoolSize()，）
keepAliveTime：它表示线程没有任务执行时最多保持多久时间会终止。

timeUnit：存活时间的时间单位

（注：在TimeUnit类中有7种静态属性：

TimeUnit.DAYS; //天

TimeUnit.HOURS; //小时

TimeUnit.MINUTES; //分钟

TimeUnit.SECONDS; //秒

TimeUnit.MILLISECONDS; //毫秒

TimeUnit.MICROSECONDS; //微妙

TimeUnit.NANOSECONDS; //纳秒）

workQueue：阻塞队列（用来保存等待被执行的任务）

（注：关于workQueue参数的取值,JDK提供了4种阻塞队列类型供选择：
ArrayBlockingQueue：基于数组结构的有界阻塞队列，按FIFO排序任务；
LinkedBlockingQuene：基于链表结构的阻塞队列，按FIFO排序任务，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；

SynchronousQuene：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于ArrayBlockingQuene；

PriorityBlockingQuene：具有优先级的无界阻塞队列；）

threadFactory：线程工厂，主要用来创建线程；

handler：表示当拒绝处理任务时的策略，有以下四种取值

（注：当线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了4种策略：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）

ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

　　当然也可以根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务。如：RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardPolicy(); ）

线程池的工厂类Executors

我们并不提倡直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来创建线程池，Executors类中提供创建线程池的几个静态方法（除了newScheduledThreadPool的内部实现特殊一点之外）：

newFixedThreadPool()
说明：初始化一个指定线程数的线程池，其中corePoolSize == maxiPoolSize，使用LinkedBlockingQuene作为阻塞队列
特点：即使当线程池没有可执行任务时，也不会释放线程。
newCachedThreadPool()
说明：初始化一个可以缓存线程的线程池，默认缓存60s，线程池的线程数可达到Integer.MAX_VALUE，即2147483647，内部使用SynchronousQueue作为阻塞队列；
特点：在没有任务执行时，当线程的空闲时间超过keepAliveTime，会自动释放线程资源；当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；
因此，使用时要注意控制并发的任务数，防止因创建大量的线程导致而降低性能。
newSingleThreadExecutor()
说明：初始化只有一个线程的线程池，内部使用LinkedBlockingQueue作为阻塞队列。
特点：如果该线程异常结束，会重新创建一个新的线程继续执行任务，唯一的线程可以保证所提交任务的顺序执行
newScheduledThreadPool()
特定：初始化的线程池可以在指定的时间内周期性的执行所提交的任务，在实际的业务场景中可以使用该线程池定期的同步数据。

如newCachedThreadPool()内部具体实现：

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

线程池的处理流程

（1）判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。

（2）线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。

（3）判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

线程池的五种状态

其中AtomicInteger变量ctl的功能非常强大：利用低29位表示线程池中线程数，通过高3位表示线程池的运行状态：
    RUNNING：-1 << COUNT_BITS，即高3位为111，该状态的线程池会接收新任务，并处理阻塞队列中的任务；
    SHUTDOWN： 0 << COUNT_BITS，即高3位为000，该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
    STOP ： 1 << COUNT_BITS，即高3位为001，该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
    TIDYING ： 2 << COUNT_BITS，即高3位为010，该状态表示线程池对线程进行整理优化；
    TERMINATED： 3 << COUNT_BITS，即高3位为011，该状态表示线程池停止工作；

线程池提交任务的两种方式

有两种方式：

Executor.execute(Runnable command);

ExecutorService.submit(Callable<T> task);

在ThreadPoolExecutor类中，最核心的任务提交方法是execute()方法，虽然通过submit也可以提交任务，但是实际上submit方法里面最终调用的还是execute()方法，FutureTask类实现了Runnable接口，其会将提交的Callable任务会被封装成了一个FutureTask对象。

execute()方法的内部实现：

public void execute(Runnable command) {

    if (command == null)
        throw new NullPointerException();//抛出空指针异常
    //判断当前线程数是否大于等于核心线程池大小和addIfUnderCorePoolSize()返回值
    if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
        //判断当前线程池状态是否为RUNNING，当前线程池处于RUNNING状态且将任务放入任务缓存队列成功
        if (runState == RUNNING && workQueue.offer(command)) {
        //这句判断是为了防止在将此任务添加进任务缓存队列的同时其他线程突然调用shutdown或者shutdownNow方法关闭了线程池的一种应急措施。
            if (runState != RUNNING || poolSize == 0)

                ensureQueuedTaskHandled(command);

        }
        //如果执行addIfUnderMaximumPoolSize方法失败，则执行reject()方法进行任务拒绝处理。
        else if (!addIfUnderMaximumPoolSize(command))
            reject(command); // is shutdown or saturated

    }

}

private boolean addIfUnderCorePoolSize(Runnable firstTask) {
    Thread t = null;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (poolSize < corePoolSize && runState == RUNNING)
            t = addThread(firstTask);        //创建线程去执行firstTask任务   
        } finally {
        mainLock.unlock();
    }
    if (t == null)
        return false;
    t.start();
    return true;
}

private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
    Thread t = null;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (poolSize < maximumPoolSize && runState == RUNNING)
            t = addThread(firstTask);
    } finally {
        mainLock.unlock();
    }
    if (t == null)
        return false;
    t.start();
    return true;
}

线程池的关闭

ThreadPoolExecutor提供了两个方法，用于线程池的关闭，分别是shutdown()和shutdownNow()，其中：

shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务

shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

参考资料：

Java中线程池的实现原理-求职必备 - 简笔话_Golden - 博客园

Java线程池原理及四种线程池的使用_Herman-Hong的博客-CSDN博客_java 线程池

线程池原理(讲的非常棒)_Golphing的博客-CSDN博客

我的书包哪里去了

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java线程池实现原理

文章目录线程池简介线程池核心类ThreadPoolExecutor 线程池的工厂类Executors 线程池的处理流程线程池的五种状态线程池提交任务的两种方式线程池的关闭线程池简介多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减...
复制链接

扫一扫