【Java 并发编程】线程池机制 ( 线程池执行任务细节分析 | 线程池执行 execute 源码分析 | 先创建核心线程 | 再放入阻塞队列 | 最后创建非核心线程 )

简介: 【Java 并发编程】线程池机制 ( 线程池执行任务细节分析 | 线程池执行 execute 源码分析 | 先创建核心线程 | 再放入阻塞队列 | 最后创建非核心线程 )

文章目录

一、线程池执行任务细节分析

二、线程池执行 execute 源码分析





一、线程池执行任务细节分析


线程池执行细节分析 :


核心线程数 10 1010 , 最大小成熟 20 2020 , 非核心线程数 10 1010 , 非核心线程空闲存活时间 60 6060 秒 , 阻塞队列大小 10 1010 个 ;


当有 Runnable 任务进入线程池后 ;


先查看 " 核心线程 " , 如果没有核心线程 , 先 创建核心线程 ;


如果有核心线程 , 则 查看核心线程是否有空闲的 ;


如果有空闲的核心线程 , 直接将该任务分配给该空闲核心线程 ;


如果没有空闲核心线程 , 则 查看核心线程数有没有满 ;


如果核心线程没有满 , 则 创建一个核心线程 , 然后执行该任务 ;


如果核心线程满了 , 将该任务放入 " 阻塞队列 " 中 , 查看阻塞队列是否已满 ;


如果阻塞队列没有满 , 直接 将任务放入阻塞队列中 ;


如果阻塞队列满了 , 则 查看是否能创建 " 非核心线程 " ;


如果能创建非核心线程 , 则 创建非核心线程 , 并执行该任务 ;


如果不能创建非核心线程 , 则 执行 " 拒绝策略 " ;






二、线程池执行 execute 源码分析


查看传入的 Runnable 任务是否为空 , 如果为空 , 就报异常 ;


 

if (command == null)
            throw new NullPointerException();


获取当前线程池的状态 , 根据不同的状态 , 执行不同的操作 ;


     

/*
         * 进行以下三个步骤处理:
         *
         * 1. 如果当前运行的线程 , 小于核心线程数 , 那么创建一个新的核心线程 , 
         * 将传入的任务作为该线程的第一个任务 . 
         * 调用 addWorker 方法 , 会原子性检查运行状态和任务数量 ; 
         * 如果在不应该添加线程的情况下执行添加线程操作 , 就会发出错误警报 ; 
         * 如果该方法返回 false , 说明当前不能添加线程 , 此时就不要执行添加线程的操作了 ; 
         *
         * 2. 如果任务被成功放入 线程池任务 队列 , 不管我们此时是否应该添加线程 , 都需要进行双重验证 ;
         * 双重验证 : 添加到任务队列时验证一次 , 添加到线程执行时验证一次 ; 
         * 可能存在这种情况 , 在上次验证线程运行状态之后 , 有可能该线程就立刻被销毁了 ;
         * 也可能存在进入该方法后 , 线程池被销毁的情况 ; 
         * 因此我们反复验证线程状态 , 如果需要在线程停止时回滚队列 , 如果没有线程就创建新线程 ;
         *
         * 3. 如果不能将任务放入队列中 , 尝试创建一个新线程 ; 
         * 如果创建线程失败 , 说明当前线程池关闭 , 或者线程池中线程饱和 , 此时拒绝执行该任务 ; 
         */
        int c = ctl.get();


上述 AtomicInteger ctl 线程池状态是很关键的原子变量 , 该原子变量中同时包含了线程池的线程数量 , 该值是一个组合的数值 ; 该 int 值 4 44 字节 32 3232 位 , 前 3 33 位是线程池的状态位 , 剩下的 29 2929 位是线程数 ;


/**
  * 主池控制状态ctl是一个原子整数
  * 两个概念领域
  * workerCount,指示有效线程数
  * 运行状态,指示是否运行、关闭等
  * 
  * 为了将它们打包成一个整数,我们将workerCount限制为
  * (2^29)-1(约5亿)个线程,而不是(2^31)-1(2
  * 10亿)否则可代表。如果这曾经是一个问题
  * 将来,变量可以更改为原子长度,
  * 下面的移位/遮罩常数已调整。但在需要之前
  * 因此,此代码使用int更快更简单。
  * 
  * workerCount是已注册的工人数
  * 允许启动,不允许停止。该值可能是
  * 与活动线程的实际数量暂时不同,
  * 例如,ThreadFactory在以下情况下无法创建线程:
  * 当退出线程仍在执行时
  * 终止前的簿记。用户可见池大小为
  * 报告为工作集的当前大小。
  * 
  * 运行状态提供主要的生命周期控制,具有以下值:
  * 
  * 正在运行:接受新任务和处理排队的任务
  * 关机:不接受新任务,但处理排队的任务
  * 停止:不接受新任务,不处理排队的任务,
  * 并中断正在进行的任务
  * 整理:所有任务都已终止,workerCount为零,
  * 正在转换为状态整理的线程
  * 将运行终止的()钩子方法
  * 终止:终止()已完成
  * 
  * 这些值之间的数字顺序很重要,以允许
  * 有序比较。运行状态随时间单调增加
  * 时间,但不需要击中每个状态。这些转变是:
  * 
  * 运行->关机
  * 在调用shutdown()时,可能隐式地在finalize()中
  * (运行或关闭)->停止
  * 在调用shutdownNow()时
  * 关机->整理
  * 当队列和池都为空时
  * 停止->整理
  * 当池为空时
  * 清理->终止
  * 当终止的()钩子方法完成时
  * 
  * 等待终止()的线程将在
  * 国家终止。
  * 
  * 检测从关闭到清理的过渡较少
  * 比您希望的简单,因为队列可能会
  * 非空后为空,关机状态下为空,但
  * 只有在看到它是空的之后,我们才能终止
  * workerCount为0(有时需要重新检查——请参阅
  * 下)。
  */
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    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;
    // Packing and unpacking ctl
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }


简单的机翻了下 , 如果查看详细的英文注释 , 查看 libcore/ojluni/src/main/java/java/util/concurrent/ThreadPoolExecutor.java 源码 ;



线程池的状态如下 , 有 5 55 种状态 ;


 

// 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;


判断当前的工作线程数 workerCountOf(c) 是否小于核心线程数 corePoolSize ;


如果小于 , 则添加核心线程 addWorker(command, true) ;


这里注意 , 来了新任务后 , 不是先将任务放入阻塞队列 , 而是检查核心线程 , 先尝试将核心线程部署满 ;


   

if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }


判断当前的线程池状态 isRunning(c) 是否正在执行处于 RUNNING 状态 , 如果当前线程池处于 RUNNING 状态 , 说明所有的核心线程都满了 , 则将任务队列放入阻塞队列中 workQueue.offer(command) ;


如果可以入队 , 重新检查状态 , 如果必要 回滚排队 ! isRunning(recheck) && remove(command) , 重新检查状态通过后 , addWorker(null, false) 将任务添加如阻塞队列中 ;


入队失败 , 尝试添加非核心线程 !addWorker(command, false) , 如果非核心线程也失败 , 则执行拒绝策略 reject(command) ;

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);
目录
相关文章
|
2月前
|
安全 Java 程序员
深入理解Java内存模型与并发编程####
本文旨在探讨Java内存模型(JMM)的复杂性及其对并发编程的影响,不同于传统的摘要形式,本文将以一个实际案例为引子,逐步揭示JMM的核心概念,包括原子性、可见性、有序性,以及这些特性在多线程环境下的具体表现。通过对比分析不同并发工具类的应用,如synchronized、volatile关键字、Lock接口及其实现等,本文将展示如何在实践中有效利用JMM来设计高效且安全的并发程序。最后,还将简要介绍Java 8及更高版本中引入的新特性,如StampedLock,以及它们如何进一步优化多线程编程模型。 ####
49 0
|
1月前
|
监控 Java
java异步判断线程池所有任务是否执行完
通过上述步骤,您可以在Java中实现异步判断线程池所有任务是否执行完毕。这种方法使用了 `CompletionService`来监控任务的完成情况,并通过一个独立线程异步检查所有任务的执行状态。这种设计不仅简洁高效,还能确保在大量任务处理时程序的稳定性和可维护性。希望本文能为您的开发工作提供实用的指导和帮助。
98 17
|
2月前
|
存储 监控 小程序
Java中的线程池优化实践####
本文深入探讨了Java中线程池的工作原理,分析了常见的线程池类型及其适用场景,并通过实际案例展示了如何根据应用需求进行线程池的优化配置。文章首先介绍了线程池的基本概念和核心参数,随后详细阐述了几种常见的线程池实现(如FixedThreadPool、CachedThreadPool、ScheduledThreadPool等)的特点及使用场景。接着,通过一个电商系统订单处理的实际案例,分析了线程池参数设置不当导致的性能问题,并提出了相应的优化策略。最终,总结了线程池优化的最佳实践,旨在帮助开发者更好地利用Java线程池提升应用性能和稳定性。 ####
|
2月前
|
监控 Java 开发者
深入理解Java中的线程池实现原理及其性能优化####
本文旨在揭示Java中线程池的核心工作机制,通过剖析其背后的设计思想与实现细节,为读者提供一份详尽的线程池性能优化指南。不同于传统的技术教程,本文将采用一种互动式探索的方式,带领大家从理论到实践,逐步揭开线程池高效管理线程资源的奥秘。无论你是Java并发编程的初学者,还是寻求性能调优技巧的资深开发者,都能在本文中找到有价值的内容。 ####
|
2月前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
1月前
|
缓存 安全 算法
Java 多线程 面试题
Java 多线程 相关基础面试题
|
2月前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
|
2月前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介:本文介绍了Java中常见的线程池类型,包括`newCachedThreadPool`(适用于短期异步任务)、`newFixedThreadPool`(适用于固定数量的长期任务)、`newScheduledThreadPool`(支持定时和周期性任务)以及`newSingleThreadExecutor`(保证任务顺序执行)。同时,文章还讲解了Java中的锁机制,如`synchronized`关键字、CAS操作及其实现方式,并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。
|
2月前
|
安全 Java 编译器
深入理解Java中synchronized三种使用方式:助您写出线程安全的代码
`synchronized` 是 Java 中的关键字,用于实现线程同步,确保多个线程互斥访问共享资源。它通过内置的监视器锁机制,防止多个线程同时执行被 `synchronized` 修饰的方法或代码块。`synchronized` 可以修饰非静态方法、静态方法和代码块,分别锁定实例对象、类对象或指定的对象。其底层原理基于 JVM 的指令和对象的监视器,JDK 1.6 后引入了偏向锁、轻量级锁等优化措施,提高了性能。
69 3
|
2月前
|
存储 安全 Java
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
209 2

热门文章

最新文章