深入java虚拟机-第五部分-高效并发
第12章 Java内存模型与线程
并发处理的广泛应用 是使得 Amdah1定律 代替 摩尔定律 成为计算机性能发展源动力 的根本原因, 也是人类 “压榨” 计算机运算能力的最有利武器。
Amdah1定律 代替 摩尔定律 成为 计算机性能发展源动力 的根本原因: 并发处理的广泛应用。
Amdah1定律
- 通过系统中 并行化与串行化 的 比重 来 描述 多处理器系统 能获得的 运算加速能力;
摩尔定律
- 则用于 描述 处理器 晶体管数量 与 运行效率 之间的发展关系。
这两个定律 的 更替 代表了:近年来 硬件发展 从追求 处理器频率 到 追求 多核心并行处理 的发展过程;
概述
多任务处理 在 现代计算机操作系统 中 几乎已是一项必备的技能了。
现代计算机操作系统 中,多任务处理 几乎已是一项必备的技能。
在许多情况下,让 计算机 同时去做几件事情, 不仅是因为 计算机的运算能力强大 了,还要一个很重要的原因是 计算机的运算速度 与 它的存储和通信子系统速度 的 差距太大,
大量的时间都花费在磁盘I/O 、网络通信或者 数据库访问上。
让计算机同时去做几件事情的原因:
- 计算机的运算能力强大
- 计算机的 运算速度 与 它的 存储和通信子系统 速度 的差距太大;
- 为了避免大量的时间都花费在 磁盘I/O、网络通信、访问数据库上;
如果不希望 处理器 在大部分时间里都处于 等待其他资源的状态,
就必须 使用一些手段 去把 处理器的预算能力 压榨 出来,
否则就会造成很大的浪费,
而让计算机 同时处理几项任务 则是最容易想到、也被证明 是非常有效的“压榨”手段;
处理器 在大部分时间里 都处于 等待其他资源的状态
解决 处理器在大部分时间里 都处于 等待其他资源的状态 的手段 or 如何将 处理器的预算能力 压榨出来:
- 让计算机 同时处理几项任务(最容易想到、也被证明是非常有效的“压榨”手段)
除了充分利用 计算机处理器的能力 外,一个服务端 同时对 多个客户端提供服务 则是另一个更具体的并发应用场景。
具体的并发应用场景:
- 一个服务端 同时对 多个客户端 提供服务。
- 充分利用计算机处理器的能力(让计算机同时处理几项任务);
衡量 一个服务性能 的 高低好坏,
每秒事务处理数(Transactions Per Second, TPS)是最重要的指标之一,
它代表着 一秒内 服务端 平均 能响应 的请求总数,
而 TPS 值 与 程序的 并发能力 又有 非常密切的关系。
每秒事务处理数(Transactions Per Second ,TPS)
- 每秒事务处理数(Transactions Per Second ,TPS)是 衡量一个服务性能高低好坏的最重要指标之一
- 每秒事务处理数(Transactions Per Second ,TPS) 代表着 一秒内 服务端的 平均 能响应 的 请求总数;
- 每秒事务处理数(Transactions Per Second ,TPS)与 程序的并发能力 有着非常密切的关系。
对于 计算量相同 的任务, 程序线程 并发协调 得 越有条不紊,效率自然就会提高;
反之,线程之间 频繁阻塞 甚至 死锁,将会大大 降低 程序 的 并发能力。
计算量相同的任务,线程之间状态不同将导致不同的结果:
- 程序线程 并发协调 有条不紊,效率提高;
- 线程之间 频繁阻塞 甚至 死锁,将会大大 降低 程序 的 并发 能力;
服务端 是 java语言 最擅长的领域之一,这个领域的应用 占了 Java应用中最大的一块份额,
必须以 代码的总体规模 来衡量, 服务端应用 不能与 JavaCard、移动终端 这些领域去比 绝对数量。
不过 如何写好 并发应用程序 却又是 服务端程序开发的难点之一, 处理好并发方面的问题 通常需要更多的 编码经验 来支持。
服务端 领域的应用 占用了java应用 中最大的一块份额。
服务端 程序开发的难点之一:如何写好 并发应用程序;
处理好并发方面的问题:通常需要更多的 编码经验 来支持;
幸好 java语言和虚拟机 提供了许多工具,把 并发编程 的门槛 降低了不少。
并且各种 中间件服务器、各类框架 都努力地替程序员 处理尽可能多的线程并发细节,
使得程序员 在编码时能 更关注业务逻辑,
而 不是花费大部分时间去 关注此服务 会同时被多少人调用、如何协调硬件资源。
- 各种 中间件服务器、各类框架 处理尽可能多的线程并发细节;
- 程序员能够关注业务逻辑,避免花费大部分时间去 关注此服务 会同时被多少人调用、如何协调硬件资源等
无论语言、中间件和框架 如何先进,开发人员都不能期望 它们能独立完成所有并发处理的事情,了解 并发的内幕 也是 称为一个高级程序员 不可缺少的课程。
(🙃尽管我是如此垃圾,但是我依然热爱-----个屁🙃)
不能去期望 某种语言、中间件或者框架 能够独立完成所有并发处理的事情。
“高效并发” 是本书 讲解java虚拟机的最后一部分,
将会向读者介绍 虚拟机 如何实现 多线程、多线程之间 由于 共享 和 竞争数据 而 导致的 一系列 问题 及 解决方案。
硬件的效率 与 一致性
在正式讲解 java虚拟机并发相关 的知识之前,我们先花费一点时间去了解一下 物理计算机中的 并发问题,
物理机遇到的 并发问题 与 虚拟机中的情况 有不少相似之处,
物理机 对 并发的处理方案 对于 虚拟机的实现 也有相当大的参考意义。
物理机与虚拟机
- 物理机 遇到的 并发问题 与 虚拟机中的情况 有不少相似之处;
- 物理机 对 并发的处理方案 对于 虚拟机的实现 也有相当大的参考意义。
“让 计算机 并发执行 若干个 运算任务” 与 “更充分 地 利用 计算机处理器的效能” 之间的因果关系,看起来顺理成章,
实际上他们之间的关系 并没有想象中的那么简单,
其中一个 重要的复杂性 来源是 绝大多数的 运算任务 都 不可能 只靠 处理器“计算” 就能完成,
处理器 至少 要与 内存交互,
如读取运算数据、存储运算结果等,
这个I/O操作是很难消除的
(无法仅靠寄存器来完成所有运算任务)。
由于 计算机的存储设备 与 处理器的运算速度 有几个数量级的差距,
所以 现代计算机系统 都不得不加入 一层 读写速度 尽可能接近 处理器运算速度 的 高速缓存(Cache) 来作为 内存与处理器 之间的缓冲:
将运算需要使用的数据 复制到 缓存中,
让运算能快速进行,
当运算结束后 再从 缓存 同步回 内存之中,
这样 处理器 就 无需等待 缓慢的 内存读写 了。
“让计算机 并发执行 若干个运算任务” 与 “更充分地利用计算机处理器的效能”之间因果关系的复杂性来源
- 绝大多数的运算任务都不可能只靠 处理器“计算” 就能完成
- 处理器 至少 要与 内存交互(如读取运算数据、存储运算结果等);这个I/O操作是很难消除的;
- 无法仅靠寄存器来完成所有运算任务;
- 计算机的存储设备 与 处理器的运算速度 有几个数量级的 差距。
- 现代计算机系统中加入了 一层 (读写速度尽可能接近处理器运算速度) 的 高速缓存(Cache) 来作为 内存与处理器之间的缓冲:
- 将 运算 所需要使用到的 数据 复制到 缓存 中;
- 让运算能快速进行;
- 当运算结束后,再从 缓存 同步 回 内存 之中;
- 这样处理器 就无需等待 缓慢的 内存读写 了;
基于 高速缓存 的 存储交互 很好地解决了 处理器 与 内存 的速度矛盾,
但是也为 计算机系统 带来更高的复杂度,
因为它引入了一个新的问题: 缓存一致性(Cache Coherence)。
高速缓存 的 存储交互 优缺点:
- 优点:解决了 处理器与内存 之间的 速度矛盾;
- 缺点:带来了新问题-缓存一致性(Cache Coherence)
在 多处理器系统 中,每个 处理器 都有 自己的 高速缓存,而它们又 共享 同一主内存(Main Memory)。
当 多个处理器的运算任务 都设计 同一块 主内存区域 时,
将可能导致 各自的缓存数据不一致,
如果真的发生这种情况,那同步回到 主内存时 以谁的缓存数据为准呢?
为了解决一致性的问题,
需要 各个 处理器 访问缓存 时 都 遵循 一些 协议,
在读写时 要根据协议 来进行操作,
这类协议有 MSI、MESI(Illinois Protocl)、MOSI、Synapse、Firefly 及 Dragon Protocol 等。
在本章中将会多次提到的 “内存模型” 一词,
可以理解为 在特定的操作协议下,对 特定的内存或高速缓存 进行 读写访问的过程抽象。
不同架构的物理机器 可以拥有 不一样的内存模型,
而 java虚拟机 也有自己的内存模型,
并且这里介绍的 内存访问操作 与 硬件的缓存访问操作具有很高的可比性。
--------- ----------- ---------------- ------ | 处理器 | <----------> | 高速缓存 | <----------> | 缓存 | <----------> | 主 | --------- ----------- | | | | --------- ----------- | | | | | 处理器 | <----------> | 高速缓存 | <----------> | 一致性 | <----------> | 内 | --------- ----------- | | | | --------- ----------- | | | | | 处理器 | <----------> | 高速缓存 | <----------> | 协议 | <----------> | 存 | --------- ----------- ---------------- ------
讯享网
除了 增加 高速缓存 之外,
为了使得 处理器内部 的 运算单位 能尽量被 充分使用,
处理器 可能会对 输入代码 进行 乱序执行(Out-Of-Order Execution)优化,
处理器 会在 计算之后 将乱序执行的结果 重组,
保证 该结果 与 顺序执行 的结果是一致的,
但 并不保证 程序中 各个语句 计算的先后顺序 与 输入代码中的顺序 一致,
因此 ,
如果存在 一个计算任务 依赖 另外一个 计算任务的 中间结果,
那么其 顺序性并不能靠 代码的先后顺序 来保证。
与 处理器的乱序执行优化 类似,
java虚拟机 的 即时编译器 中也有类似的 指令重排序(Instruction Reorder)优化。
处理器内部 的 运算单位,如何尽可能被 充分利用?
- 增加高速缓存
- 乱序执行(Out-Of-Order Execution)优化
- 处理器 可能会对 输入代码 进行 乱序执行(Out-Of-Order Execution)优化
- 处理器 会在 计算之后 将 乱序执行的结果 重组
- 保证 该结果 与 顺序执行 的结果 是一致的;
- 但并 不保证 程序中各个语句计算的先后顺序 与 输入代码中的顺序 一致;
- 如果存在 一个计算任务 依赖 另外一个计算任务的 中间结果,那么其顺序性 并不能依靠 代码的先后顺序 来保证。
Java内存模型
Java虚拟机规范 中试图定义一种 Java内存模型(Java Memory Model,JMM)
来 屏蔽掉 各种 硬件和操作系统 的 内存访问差异,
以 实现 让 Java程序 在 各种平台 下都能达到一致的内存访问效果。
本书中的 Java内存模型 都特指 目前正在使用的,即在 JDK1.2 之后建立起来并在 JDK1.5 中完备过的内存模型。
在此之前,主流程序语言(C/C++等) 直接使用 物理硬件和操作系统的内存模型,
因此,会由于不同平台上内存模型的差异,有可能导致程序在一套平台上并发完全正常,而在另外一套平台上并发访问却经常出错,因此在某些场景就必须针对不同的平台来编写程序。
定义Java内存模型 并非一件容易的事情,
这个模型必须定义得足够严谨,才能让Java的 并发内存访问操作 不会产生歧义;
但是,也必须定义得足够宽松,使得 虚拟机的实现 有足够的自由空间 去利用 硬件的各种特性(寄存器、高速缓存和指令集中某些特有的指令)来 获取 更好的执行速度。
经过长时间的验证和修补,在 JDK1.5(实现了JSR-133)发布后,Java内存模型已经成熟和完善起来了。
JSR-133:Java Memory Model and Thread Specification Revision (Java内存模型和线程规范修订)。
主内存和工作内存
Java内存模型 的 主要目标 是 定义程序中 各个变量的 访问规则,即在 虚拟机中 将 变量存储到内存 和 从内存中取出变量 这样的底层细节。
为了获得较好的 执行效能,Java内存模型 并没有限制 执行引擎 使用处理器的 特定寄存器 或 缓存 来和主内存进行交互,也没有限制 即时编译器 进行调整代码执行顺序 这类优化措施。
Java内存模型 规定了 所有的变量 都 存储在主内存(Main Memory)中(此处的 主内存 与介绍 物理硬件时的主内存 名字一样,两者也可以互相类比,但 此处仅是 虚拟机内存 的一部分)。
每条线程 还有自己的 工作内存(Working Memory, 可与前面讲的 处理器高速缓存 类比),线程 的 工作内存 中 保存了 被该线程 使用到的 变量 的 主内存 副本拷贝,线程 对 变量 的所有操作(读取、赋值等) 都 必须在工作内存中进行, 而不能直接读写主内存中的变量。
有不少读者会对这段描述中的 “拷贝副本” 提出疑问,
如 “假设线程中访问一个10MB的对象,也会把这10MB的内存复制一份拷贝出来吗?”
事实上并不会如此,这个对象的引用、对象中某个在线程访问到的字段 是有可能存在拷贝的,但 不会有 虚拟机 实现成 把整个对象拷贝一次。
根据 Java虚拟机规范 的规定
volatile变量 依然有工作内存的拷贝
但是由于 它 特殊的操作顺序性规定(后文会讲到),
所以看起来如同直接在主内存中读写访问一般,因此这里的描述对于 volatile也并不存在例外。
不同的 线程之间 也无法 直接访问 对方工作内存中的 变量,线程间 变量值的传递 均需要 通过主内存来完成,线程、主内存、工作内存三者的交互关系;
讯享网------------ ----------- ---------------- ------ | Java线程 | <----------> | 工作内存 | <----------> | Save | <----------> | 主 | ------------ ----------- | 和 | | | ------------ ----------- | | | | | Java线程 | <----------> | 工作内存 | <----------> | Load | <----------> | 内 | ------------ ----------- | | | | ------------ ----------- | | | | | Java线程 | <----------> | 工作内存 | <----------> | 操作 | <----------> | 存 | ------------ ----------- ---------------- ------
这里所讲的 主内存、工作内存 与本书第2章所讲的Java内存区域中的Java堆、栈、方法区等并不是同一个层次的内存划分,
这两者基本上是没有关系的,
如果两者一定要勉强对应起来,
那从 变量、主内存、工作内存 的定义来看,
主内存 主要对应于 Java堆中的对象实例数据部分,
而 工作内存 则对应于 虚拟机栈中的部分区域。
从更低层次上说,
主内存 就直接对应于 物理硬件的内存 ,而为了 获取更好的运行速度,
虚拟机(甚至是硬件系统本身的优化措施)可能会让 工作内存 优先存储于 寄存器和高速缓存中,因为程序运行时 主要访问读写的 是工作内存。
- 有 Mark Word(存储对象哈希码、GC标志、GC年龄、同步锁等信息)
- Klass Point(指向存储类型元数据的指针)
- 及一些用于字节对齐补白的填充数据(如果实例数据刚好满足8字节对齐的话,则可以不存在补白)
内存间交互操作
关于 主内存 与 工作内存 之间的 具体的 交互协议,
即 一个变量 如何从 主内存 拷贝到 工作内存、 如何从 工作内存 同步 回 主内存 之类的 实现细节,
Java内存模型 定义了以下 8种操作 来完成,
虚拟机实现时 必须保证 下面提及的每一种操作 都是 原子的、不可再分的(对于 double 和 long 类型的变量来说,load、store、read 和 write 操作在某些平台上允许有例外,这个问题在12.3.4节再讲)
基于理解难度和严谨性考虑,最新的 JSR-133 文档中,已经放弃采用这8种操作去 定义Java内存模型的访问协议(仅是 描述方式 改变了,Java内存模型 并没有改变)。
| operation | 名称 | 作用变量 | 描述 |
|---|---|---|---|
| lock | (锁定) | 作用于 主内存 的 变量 | 它把 一个 变量 标识为 一条线程 独占 的 状态。 |
| unlock | (解锁) | 作用于 主内存 的 变量 | 它把 一个 处于锁定状态 的变量 释放出来,释放后的变量 才可以 被 其他线程 锁定。 |
| read | (读取) | 作用于 主内存 的 变量 | 它把 一个 变量的值 从 主内存 传输到 线程的工作内存中,以便随后的 load动作 使用。 |
| load | (载入) | 作用于 工作内存 的 变量 | 它把 read操作 从 主内存 中得到的 变量值 放入 工作内存 的变量副本 中。 |
| use | (使用) | 作用于 工作内存 的 变量 | 它把 工作内存中 一个变量的值 传递给 执行引擎,每当 虚拟机 遇到一个 需要使用到变量的值 的字节码指令时 将会执行这个操作。 |
| assign | (赋值) | 作用于 工作内存 的 变量 | 它把 一个 从执行引擎 接收到的值 赋给 工作内存的变量,每当 虚拟机 遇到 一个给变量赋值的字节码指令 时 执行这个操作。 |
| store | (存储) | 作用于 工作内存 的 变量 | 它把 工作内存 中 一个变量的值 传送到 主内存 中,以便 随后的write操作 使用。 |
| write | (写入) | 作用于 主内存 的 变量 | 它把 store操作 从 工作内存 中得到的 变量的值 放入 主内存 的 变量 中。 |
注意, Java内存模型 只要求上述 两个操作 必须按顺序执行,而没有保证是 连续执行。
也就是说,read和load之间,store和write之间 是可插入其他指令的,
如对主内存中的变量 a、b进行访问时,一种可能出现顺序是 read a、read b、load b、 load a。
除此之外,Java内存模型 还规定了 在执行上述8中基本操作时 必须满足如下规则:
- 不允许 read和load、store和write 操作之一 单独出现;
- 即 不允许 一个变量 从主内存读取了 但工作内存不接受;
- 或者从工作内存发起回写了 但主内存不接受的情况出现。
- 不允许 一个线程 丢弃 它的 最近的 assign操作;
- 即 变量 在 工作内存 中 改变了 之后 必须把 该变化 同步回 主内存。
- 不允许 一个线程 无原因地(没有发生过任何assign操作)把 数据 从 线程的工作内存 同步回 主内存。
- 一个 新的变量 只能在 主内存 中“诞生”, 不允许 在工作内存中 直接使用 一个未被初始化(load或assign)的变量;
- 换句话说,就是对 一个变量 实施 use、store操作之前,必须先执行过了 assign或load 操作;
- 一个变量 在 同一时刻 只允许 一条线程 对其进行 lock操作,但 lock操作 可以被 同一条线程 执行多次,多次执行lock后,只有执行相同次数的 unlock操作,变量才会被解锁;
- 如果对 一个变量 执行 lock操作,那将会 清空工作内存 中 此变量的值,在 执行引擎 使用这个变量前,需要重新执行 load或assign操作 初始化变量的值。
- 如果 一个变量 事先没有被 lock操作 锁定,那就不允许 对它执行 unlock操作,也不允许去 unlock 一个被其他线程锁定住的 变量。
- 对 一个变量 执行 unlock操作 之前,必须先把 此变量 同步回 主内存 中(执行 store、write操作);
这 8种内存访问操作 以及 上述规则限定,再加上稍后介绍的对 volatile 的一些特殊规定,就已经完全确定了 java程序中 哪些内存访问操作 在并发下 是安全的。
对于 volatile 型变量的 特殊规则
关键字 volatile 可以说是 Java虚拟机 提供的 最轻量级 的 同步机制,
但是它 并不容易 完全被正确、 完整地理解,以至于许多程序员都习惯不去使用它,
遇到需要处理 多线程数据 竞争问题 的时候 一律使用 synchronized 来进行 同步。
(然而我也不是习惯不习惯的问题,是我根本不会用synchronized,不懂多线程并发这一块,根本没入门的问题)
Java内存模型 对 volatile 专门定义了 一些 特殊的访问规则,
在介绍 这些比较 拗口的规则定义 之前,笔者先用 不那么正式 但 通俗易懂的 语言 来介绍一下 这个关键字的作用。
(好人一生平安~~~ 虽然我也不一定能看懂你通俗易懂的语言)
当 一个变量 定义为 volatile 之后,它 将具备 两种特性,
第一 是保证 此变量 对 所有线程 的 可见性,
这里的 “可见性” 是指当 一条线程 修改了 这个 变量的值,新值 对于 其他线程 来说 是可以立即得知的。
而 普通变量 不能做到这一点, 普通变量 的 值 在线程间 传递 均需要通过 主内存 来完成,
例如,线程A 修改 一个普通变量的值,然后 向 主内存 进行 回写,另外一条线程B 在线程A 回写完成 了之后 再从 主内存 进行 读取 操作,新变量值 才会对线程B可见。
(诶诶诶,这个我看懂了,可能原因在于我看了视频的原因,我怎么可以这么蠢。。。。)
关于 volatile变量的可见性,经常会被开发人员误会,认为以下描述成立:“volatile变量 对所有线程 是 立即可见 的,对 volatile变量 所有的 写操作 都能 立刻反应 到 其他线程之中,换句话说, volatile变量 在 各个线程中 是 一致的,所以基于 volatile变量 的 运算 在并发下 是安全的”。
这句话的论据部分 并没有错, 但是其论据 并不能得出 “基于 volatile变量 的 运算 在并发下 是安全的”这个结论。
(emm,我觉得论据部分也有点毛病,
个人观点:“volatile变量 对所有线程 是 立即可见的”, 立即可见吗?
不是之前说 普通变量的值在线程间传递均需要通过主内存来完成吗,
那既然是要通过主内存来完成的话,那是不是就需要执行那8个操作其中的read读取操作以及load、use操作等;
然后论据部分当中的 “对volatile变量 所有的 写操作 都能 立刻反应 到其他线程之中” 细品一下哦,能立刻反应?
不是8个操作当中工作内存的赋值操作assign这种的操作一旦有了还需要同步回主内存的吗?
也就是执行store以及write操作,以及立刻反映到其他线程之中难道不要 其他线程又要去清空其工作内存当中的该变量然后重新进行read、load…操作之类的?
还是说emm,
工作内存与主内存之间的这个交互非常快?快到那几个操作所需花费时间可以忽略不计所以说 立即可见、立即反应?
害,主要是自己也不懂,看了书和视频之后吧有问题也没有人可以解答下…〒▽〒)
volatile变量 在 各个线程的 工作内存 中不存在一致性问题
(在 各个线程的 工作内存中,volatile变量 也可以存在 不一致的 情况,但由于 每次使用之前 都要先刷新,执行引擎 看不到 不一致的情况,因此可以认为 不存在一致性问题),
但是Java里面的运算 并非 原子操作,导致 volatile变量 的运算 在 并发下一样是不安全的,
我们可以 通过一段简单的演示来说明原因,请看代码清单12-1 中演示的例子。
代码清单 12-1 volatile 的运算 ---------------------------------------------------------------------------------------------- / * volatile 变量自增运算测试 * * @author zzm */ public class VolatileTest { public static volatile int race = 0; public static void increase(){ race++; } private static final int THREADS_COUNT = 20; public static void main(String[] args){ Thread[] threads = new Thread[THREADS_COUNT]; for(int i = 0; i < THREADS_COUNT; i++){ threads[i] = new Thread(new Runnable(){ @Override public void run(){ for(int i = 0; i < 10000; i++){ increase(); } } }); threads[i].start(); } //等待所有累加线程都结束 while(Thread.activeCount() > 1) Thread.yield(); System.out.println(race); } } ----------------------------------------------------------------------------------------------
这段代码 发起了20个线程,每个线程 对 race变量 进行10000次自增操作,如果这段代码能够 正确并发 的话,最后输出的结果应该是。
读者运行完这段代码之后,并不会获得期望的结果,而且会发现 每次运行程序,输出的结果都不一样,都是一个小于 的数字,这是为什么呢?
问题就出现在 自增运算 “race++”之中,
我们用 Javap 反编译 这段代码之后,会得到代码清单12-2,
发现只有一行代码的 increase() 方法在 Class文件 中是由 4条字节码指令构成的(return 指令不是由 race++ 产生的,这条指令可以不计算),
从 字节码层面上 很容易就分析出 并发失败 的原因了:
当 getstatic指令 把 race 的值 取到 操作栈顶时,volatile关键字 保证了 race的值 在此时是正确的的,
但是在执行 iconst_1、iadd这些指令的时候,
其他线程 可能已经把 race的值 加大了,
而在 操作栈顶 的值 就变成了 过期的数据,
所以 putstatic 指令执行后就可能把 较小的 race值 同步回 主内存之中。
(恭喜我,竟然又看懂了这一段通俗易懂的话,原因可能在于我看了视频的缘故。。。)
讯享网 代码清单 12-2 VolatileTest 的字节码 ---------------------------------------------------------------------------------------------- public static void increase(); Code: Stack=2, Locals=0, Args_size=0 0: getstatic #13; //Field race:I 3: iconst_1 4: iadd 5: putstatic #13; //Field race:I 8: return LineNumberTable: Line 14: 0 Line 15: 8 ----------------------------------------------------------------------------------------------
一条字节码指令 在 解释执行 时,解释器将要运行许多代码才能实现 它的语义,
如果是 编译执行,一条字节码指令 也可能 转化成若干条 本地机器码指令,
此处使用 -XX:+PrintAssembly 参数输出 反汇编 来分析会 更严谨 一些,
但考虑到读者阅读的方便,并且字节码已经能说明问题,所以此处使用字节码分析。
(我觉得这个考虑到读者方便,可能是考虑到了像我这种小白到时候看不懂,就解释的也就越讲越多越讲越多。。。。 真是太贴心了,贴心的暖宝宝)
- 运算结果 并不依赖 变量 的当前值,或者 能够确保 只有单一的线程修改 变量的值。
- 变量 不需要 与 其他的状态变量 共同参与 不变约束。
而在像 如下的代码清代12-3所示的 这类场景就很适合使用 volatile变量 来控制并发,当 shutdown() 方法被调用时,能保证 所有线程 中执行的 doWork() 方法都立即停下来。
代码清单 12-3 volatile 的使用场景 ---------------------------------------------------------------------------------------------- volatile boolean shutdownRequested; public void shutdown(){ shutdownRequested = true; } public void doWork(){ while(!shutdownRequested){ // do stuff } } ----------------------------------------------------------------------------------------------
使用 volatile变量 的第二个语义 是 禁止指令重排序优化,
普通的变量 仅仅 会保证 在该方法的执行过程中 所有依赖 赋值结果 的地方 都能获取到 正确的结果,
而不能 保证 变量赋值 操作的顺序 与 程序代码中的执行顺序 一致。
上面的描述仍然不太容易理解,我们还是继续通过一个例子来看看为何 指令重排序 会 干扰 程序的并发执行,
演示程序如代码清单12-4所示。
(周大大真是说到我的心坎里去了,真是太为我这种人考虑了,岂止是不太容易理解!!简直,我都不好意思说自己是中国人了。害;╮(╯▽╰)╭)
讯享网 代码清单 12-4 指令重排序 ---------------------------------------------------------------------------------------------- Map configOptions; char[] configText; // 此 变量 必须定义为 volatile volatile boolean initialized = false; // 假设以下代码在 线程A 中执行 // 模拟 读取配置信息,当读取完成后 将 initialized 设置为 true 以通知其他线程 配置可用 configOptions = new HashMap(); configText = readConfigFile(fileName); processConfigOptions(configText, configOptions); initialized = true; // 假设以下代码在 线程B 中执行 // 等待 initialized 为 true,代表 线程A 已经把配置信息 初始化完成 while (!initialized){ sleep(); } // 使用 线程A 中初始化好的配置信息 doSomethingWithConfig(); ----------------------------------------------------------------------------------------------
代码清单12-4中的程序是一段 伪代码,其中描述的场景十分常见,只是我们在处理配置文件时一般不会出现并发而已。
如果定义 initialized变量 没有使用 volatile修饰,
就可能会由于 指令重排序的优化,
导致位于 线程A 中的最后一句代码 “initialized=true”被提前执行(这里虽然使用Java作为伪代码,但所指的 重排序优化 是 机器级 的 优化 操作,提前执行 是指 这句话对应的 汇编代码 被 提前执行),
这样在 线程B 中使用配置信息的代码 就可能出现错误,
而 volatile关键字 则可以避免此类情况的发生。
代码清单 12-5 DCL单例模式 ---------------------------------------------------------------------------------------------- public class Singleton{ private volatile static Singleton instance; public static Singleton getInstance(){ if(instance == null){ synchronized ( Singleton.class ){ if(instance ==null ){ instance = new Singleton(); } } } return instance; } public static void main(String[] args){ Singleton.getInstance(); } } ----------------------------------------------------------------------------------------------
编译后,这段代码对 instance变量 赋值部分 如代码清单12-6所示。
(卧槽,我有病我为什么要抄这个代码清单12-6…)
讯享网 代码清单 12-6 ---------------------------------------------------------------------------------------------- 0x01a3de0f: mov $0x3375cdb0,%esi ; ...beb0cd75 33 ; {oop('Singleton')} 0x01a3de14: mov %eax,0x150(%esi) ; ... 0000 0x01a3de1a: shr $0x9,%esi ; ...clee09 0x01a3de1d: movb $0x0,0x(%esi) ; ...c 0x01a3de24: lock add1 $0x0,(%esp) ; ...f0 00 ; *putstatic instance ; - Singleton::getInstance@24 ----------------------------------------------------------------------------------------------
通过 对比 就会发现, 关键变化 在于有 volatile修饰的变量,
赋值后(前面 mov %eax,0x150(%esi) 这句便是赋值操作) 多执行了一个" lock add1 $0x0,(%esp)" 操作,
这个操作相当于一个 内存屏障 (Memory Barrier 或 Memory Fence,指 重排序时 不能把 后面的指令 重排序到 内存屏障 之前的位置),
只有一个 CPU 访问 内存时,并不需要 内存屏障;
但如果有 两个或更多CPU 访问 同一块 内存,且 其中有一个在 观测 另一个,就需要 内存屏障 来保证 一致性了。
这句 指令 中的 “add1 $0x0,(%esp)”(把 ESP寄存器 的 值 加 0)显然是一个 空操作
(采用这个 空操作 而不是 空操作指令nop 是因为 IA32手册规定 lock前缀 不允许 配合 nop指令 使用),
关键在于 lock前缀,查询 IA32手册,
它的作用是使得 本CPU 的 Cache 写入了 内存,
该 写入动作 也会引起 别的CPU 或者 别的内核 无效化(Invalidate)其Cache,
这种操作相当于对 Cache中的变量 做了一次 前面介绍 Java内存模式 中所说的 ”store“和”write“操作。
所以通过这样一个 空操作,可让前面 volatile变量 的 修改 对 其他CPU 立即可见。
Doug Lea 列出了各种处理器架构下的 内存屏障指令(
http://g.oswego.edu/d1/jmm/cookbook.html)
这个
http://g.oswego.edu/d1/jmm/cookbook.html我试了下访问不通;…
(看到这些文字🙃,莫名我🙃就想起了高中的数学🙃还有大学的高等数学🙃。还想起了那个斐波拉契数列还有那个KMP模式匹配算法🙃,卧槽🙃)
🙃🙃🙃捋一捋🙃🙃🙃
- 加了volatile和不加volatile的区别:“0x01a3de24: lock add1 $0x0,(%esp) ; …f0 00”这一行代码是否存在
- "0x01a3de14: mov %eax,0x150(%esi) ; … 0000"这一句是赋值操作,相当于“instance = new Singleton();”这句话?
- "add1 $0x0,(%esp)"相当于一个内存屏障;
- 内存屏障(Memory Barrier或 Memory Fence)作用:重排序时,不能把 后面的指令 重排序到 内存屏障 之前的位置
- 举个例子,就好比emm之前那个代码块,两个线程,线程A与线程B;线程A负责读取配置信息;线程B等待线程A初始化配置信息完成;完成之后进行使用线程A初始化好的配置信息;在这当中如果线程A当中“initialized=true”这句话提前执行,那么就会导致线程B的判断失误不会再执行sleep(),从而执行下面的doSomethingWithConfig()方法;而此时执行这个方法就有可能会出错;
- "add1 $0x0,(%esp)"当中的esp指的是ESP寄存器
- “add1 $0x0,(%esp)”该指令为一个空操作
- 该 空操作 导致 本CPU 的 Cache 写入了 内存;
- 本CPU的Cache写入内存 相当于 Cache中的变量 做了一次“store”与“write”,也就是 同步回内存 的意思;
- 通过将 本CPU的Cache写入内存 的该空操作,从而使得volatile变量 的修改对其他CPU立即可见
- 这个空操作是不是也就是一个刷新的操作?类似?
- 意思也就是说这个ESP寄存器的值不是加0吗,那这个ESP寄存器的值这个应该是一个常量,然后加这个0对这个常量并不会起到什么影响,但是当中会有一个写操作,也就是assign这个操作;因为执行8个操作中其中的规则有一条是:不允许一个线程无原因地(没有发生过任何assign操作)把数据从线程的工作内存同步回主内存。
- 所以会去通过这样一个空操作,让前面的 volatile变量 的修改 对其他CPU立即可见
- 对了,这个CPU,其他CPU也就相当于是主内存了是吧
那为何说 它禁止指令重排序 呢?
从 硬件架构 上讲,指令重排序 是指 CPU 采用了 允许将 多条指令 不按 程序规定的顺序 分开发送给 各相应 电路单元 处理。
但并不是说 指令任意重排, CPU 需要能 正确处理 指令 依赖情况 以保障 程序 能得出 正确的执行结果。
譬如
指令1 把 地址A 中的 值 加10,
指令2 把 地址A 中的 值 乘以2,
指令3 把 地址B 中的 值 减去3,
这时 指令1和指令2 是有依赖的,
它们之间的顺序 不能重排--------(A+10)2和 A2+10显然不相等,
但指令3 可以重排到指令1、2之前或者中间,
只要保证CPU执行后面 依赖到A、B值的操作时能获取到正确的A和B值即可。
解决了 volatile 的语义问题,再来看看在众多保障并发安全的工具中选用 volatile 的意义-------它能让我们的代码比使用其他的同步工具会更快吗?
如果让 volatile 自己与自己比较,那可以确定一个原则:
volatile变量 读操作的性能消耗 比 普通变量几乎没有什么差别,但是 写操作 则可能 会慢一些;
因为它需要 在本地代码中 插入许多 内存屏障指令 来保证 处理器 不发生 乱序执行。
在本节的最后,我们回头看一下 Java内存模型 中对 volatile变量 定义的特殊规则。
假定 T 表示一个线程,V 和 W 分别表示 两个 volatile型变量,那么在进行read、load、use、assign、store和write 操作时需要满足如下规则:
- 只有当 线程 T 对 变量 V 执行的前一个动作是 load 的时候,线程 T 才能对 变量 V 执行 use动作;
- 并且,只有当 线程 T 对 变量 V 执行的 后一个动作 是 use 的时候,线程 T 才能对 变量 V 执行 load 动作。
- 线程 T 对 变量 V 的 use动作 可以认为是 和线程 T 对 变量 V 的 load、read动作相关联,必须连续一起出现
- (这条 规则 要求在 工作内存 中,每次使用 V 前都必须先从 主内存 刷新最新的值,用于保证 能看见 其他线程 对 变量 V 所做的修改后的值)。
- 只有当 线程 T 对 变量 V 执行的前一个动作是 assign 的时候,线程 T 才能对 变量 V 执行 store 动作;
- 并且,只有当 线程 T 对变量 V 执行的 后一个动作 是 store 的时候可以认为是和 线程 T 对 变量 V 的store、write动作相关联,必须 连续 一起出现
- (这条 规则 要求在 工作内存中,每次修改 V 后都必须立刻 同步回 主内存 中,用于保证 其他线程 可以看到 自己对变量 V 所做的修改)
- 并且,只有当 线程 T 对变量 V 执行的 后一个动作 是 store 的时候可以认为是和 线程 T 对 变量 V 的store、write动作相关联,必须 连续 一起出现
- 假定 动作 A 是 线程 T 对 变量 V 实施的 use 或 assign 动作;
假定 动作 F 是和 动作 A 相关联的 load 或 store 动作,
假定 动作 P 是和 动作 F 相关联的 read 或 write 动作;
类似的,
假定 动作 B 是 线程 T 对 变量 W 实施的 use 或 assign 动作,
假定 动作 G 是和动作 B 相关联的 load 或 store 动作,
假定 动作 Q 是和动作 G 相应的对 变量 W 的 read或write 动作。
如果 A 先于 B,那么 P 先于 Q- (这条 规则 要求 volatile 修饰的变量 不会被 指令重排序优化,保证 代码的执行顺序 和 程序的顺序 相同)
理解为就好像是一个要 read-load-use 努力刷新;一个assign-store-write 努力更新一样
对于 long 和 double 型变量的特殊规则
java内存模型 要求 lock、unlock、read、load、use、assign、store、write 这个 8个操作 都具有 原子性,
但是对于 64位的数据类型( long 和 double ),在模型中特别定义了一条相对宽松的规定:允许 虚拟机 将 没有被 volatile 修饰的 64位数据的 读写操作 划分为 两次32位的操作 来进行,即允许 虚拟机 实现选择 可以 不保证64位数据类型的 load、store、read和write这个4个操作的原子性,
这点就是所谓的 long和double 的非原子性协定(Nonatomic Treatment of double and long Variables)。
不过这种读取到 “半个变量”的情况 非常罕见(在目前 商用java虚拟机 中不会出现),
因为 java内存模型 虽然允许虚拟机不把 long和double 变量的 读写 实现成原子操作,
但允许 虚拟机 选择把这些操作实现为 具有原子性的操作,而且还 “强烈建议” 虚拟机 这样实现。
原子性、可见性和有序性
原子性(Atomicity):由 Java内存模型 来直接保证的 原子性变量操作 包括 read、load、assign、use、store和write
我们大致可以认为 基本数据类型的访问读写 是具备原子性的(例外就是 long和double 的非原子性协定,读者只要知道这件事情就可以了,无需太过在意这些几乎不会发生的例外情况)
如果 应用场景 需要一个 更大范围的 原子性保证(经常会遇到),Java内存模型还提供了了 lock和unlock 操作来满足这种需求,
尽管 虚拟机 未把 lock和unlock 操作直接开放给用户使用,但是却提供了 更高层次的字节码指令 monitorenter和monitorexit 来 隐式地 使用这两个操作,这两个字节码指令反映到Java代码中 就是 同步块-----synchronized关键字,因此 synchronized 块之间的操作也具备原子性。
可见性(Visibility):可见性 是指当 一个线程 修改了 共享变量的值,其他线程 能够 立即得知 这个修改。
上文在讲解 volatile变量 的时候我们已详细讨论过这一点。
Java内存模型 是通过在 变量修改后 将 新值 同步回 主内存,在变量读取前 从 主内存 刷新变量值 这种依赖主内存作为 传递媒介 的方式来实现可见性的,无论是 普通变量 还是 volatile变量 都是如此
普通变量与volatile变量 的区别是:volatile 的 特殊规则 保证了 新值 能立即 同步到 主内存,以及每次 使用前 立即从 主内存刷新。
因此,可以说 volatile 保证了 多线程操作时 变量的可见性,而 普通变量 则不能保证这一点。
除了 volatile 之外,Java还有两个关键字 能实现可见性,即 synchronized 和 final。
同步块 的 可见性 是由 “对一个 变量 执行 unlock 操作之前, 必须先把 此变量 同步回 主内存中(执行store、write操作)”这条规则获得的,
而 final 关键字 的可见性是指:被 final 修饰的字段 在构造器中 一旦初始化完成, 并且构造器 没有把“this”的引用 传递出去(this引用逃逸 是一件很危险的事情,其他线程 有可能 通过这个引用 访问到 “初始化了一半” 的对象),那在 其他线程 中就能看见 final字段的值。
如代码清单12-7所示,变量i和j都具备可见性,它们无需同步 就能被 其他线程正确访问。
代码清单 12-7 final 与可见性 ---------------------------------------------------------------------------------------------- public static final int i; public final int j; static { i = 0; // do something } { // 也可以选择在 构造函数中 初始化 j = 0; // do something } ----------------------------------------------------------------------------------------------
有序性(Ordering):Java内存模型 的 有序性 在前面讲解 volatile 时也详细地讨论过了,
Java程序 中 天然的有序性 可以总结为一句话:
Java语言 提供了 volatile和synchronized 两个关键字 来 保证 线程之间 操作的 有序性,
volatile关键字 本身就包含了 禁止指令重排序 的语义,
而 synchronized 则是由 “一个变量在同一时刻只允许一条线程 对其进行 lock 操作”这条规则获得的,这条规则 决定了 持有同一个锁的两个同步块 只能 串行地进入;
介绍完 并发 中 3种 重要的特性后,读者有没有发现 synchronized关键字 在需要这3种特性的时候 都可以作为其中一种的 解决方案?
看起来很“万能”吧。
的确,大部分的 并发控制 操作都能使用 synchronized 来完成。
synchronized 的“万能” 也间接造就了 它被程序员滥用的 局面,越“万能”的 并发控制,通常会伴随着越大的 性能影响,
这点我们将在第13章讲解 虚拟机锁优化时在介绍。
先行发生原则
如果 Java内存模型 中所有的 有序性 都仅仅依靠 volatile 和 synchronized 来完成,那么有一些操作将会变得很 烦琐,
但是我们在编写Java并发代码的时候并没有感觉到这一点,
这是因为Java语言中有一个 “先行发生”(happens-before) 的 原则。
这个原则非常重要,它是 判断 数据是否竞争、线程是否安全 的 主要依据,依靠这个原则,我们可以通过几条规则一揽子地解决 并发环境下 两个操作之间是否可能存在冲突的所有问题。
现在就来看看 “先行发生”原则 指的是什么。
先行发生 是 Java内存模型 中定义的 两项操作 之间的 偏序关系,
如果说 操作A 先行发生于 操作B,其实就是说 发生在操作B 之前,操作A 产生的影响 能被 操作B 观察到,“影响” 包括 修改了内存中共享变量的值、发送了消息、调用了方法等。
这句话不难理解,但它 意味着什么呢?
我们可以举个例子来说明一下,如代码清单12-8中所示的这3句伪代码。
讯享网 代码清单 12-8 先行发生原则示例1 ---------------------------------------------------------------------------------------------- // 以下操作在 线程A 中执行 i = 1; // 以下操作在 线程B 中执行 j = i; // 以下操作在 线程C 中执行 i = 2; ----------------------------------------------------------------------------------------------
假设 线程A 中的操作 “i=1;” 先行发生于 线程B 的操作“j=i“ ,
那么可以确定在 线程B 的操作执行后,变量j的值一定等于1,
得出这个结论的依据有两个:
一是根据 先行发生原则, “i=1”的结果可以被观察到;
二是 线程C 还没“登场”, 线程A 操作结束之后没有其他线程 会修改变量i的值。
现在再来考虑 线程C,我们依然保持 线程A 和 线程B 之间的 先行****,
而 线程C 出现在 线程A 和 线程B 的操作之间,
但是 线程C 与 线程B 没有 先行****,
那 j 的值会是多少呢?
答案是不确定!
1和2都有可能,因为 线程C 对 变量i 的影响 可能会被 线程B 观察到,
也可能不会, 这时候 线程B 就存在 读取到 过期数据的风险,不具备 线程安全性。
如果 两个操作 之间的关系不在此列,并且无法从下列规则推导出来的话,它们就 没有顺序性保障,虚拟机 可以对它们 随意地 进行 重排序。
程序次序规则(Program Order Rule):
在 一个线程 内,按照 程序代码 顺序,书写在前面的操作 先行发生于 书写在后面的操作。
准确地说,应该是 控制流顺序 而不是 程序代码顺序, 应为要考虑 分支、循环 等结构。
*管程锁定规则(Monitor Lock Rule):
一个 unlock操作 先行发生于 后面对 同一个锁 的 lock操作。
这里必须强调的是 同一个锁,而 “后面” 是指 时间上的先后顺序。
volatile 变量规则(Volatile Variable Rule):
对 一个 volatile变量 的 写操作 先行发生于 后面对这个变量的 读操作,
这里的 “后面”同样是指 时间上的先后顺序。
线程启动规则(Thread Start Rule):
Thread 对象的 start() 方法 先行发生于 此线程的每一个动作。
线程终止规则(Thread Termination Rule):
线程 中的 所有操作 都 先行发生于 对此线程的 终止检测,
我们可以通过 Thread.join()方法结束、Thread.isAlive()的返回值 等手段 检测到 线程已经终止执行。
线程中断规则(Thread Interruption Rule):
对 线程 interrupt() 方法的调用 先行发生于 被 中断线程的代码 检测到 中断事件 的发生,可以通过 Thread.interrupted()方法 检测到 是否有中断发生。
对象终结规则(Finalizer Rule):
一个对象的 初始化 完成(构造函数执行结束) 先行发生于 它的 finalize() 方法的开始。
传递性(Transitivity):
如果 操作A 先行发生于 操作B,操作B 先行发生于 操作C,那就可以得出 操作A 先行发生于 操作C 的结论。
Java语言 无须 任何同步手段保障 就能成立的 先行发生规则 就只有上面这些了,
笔者演示一下 如何使用这些规则去判定 操作间是否具备顺序性,
对于 读写共享变量 的操作来说,就是 线程是否安全,
读者还可以从下面这个例子中感受一下 “时间上的先后顺序” 与 “先行发生” 之间有什么不同。
演示例子如代码清单12-9所示。
代码清单 12-9 先行发生原则示例2 ---------------------------------------------------------------------------------------------- private int value = 0; public void setValue(int value){ this.value=value; } public int getValue(){ return value; } ----------------------------------------------------------------------------------------------
代码清单12-9中显示的是一组再普通不过的 getter/setter 方法,
假设存在 线程A和B, 线程A先(时间上的先后)调用了 “setValue”,
然后 线程B 调用了 同一个对象 的“getValue()”,那么 线程B 收到的返回值 是什么?
由于 没有同步块,自然就不会发生 lock和unlock 操作,所以 管程锁定规则 不适用;
由于 value变量 没有被 volatile关键字 修饰,所以 volatile变量规则 不适用;
后面的 线程启动、终止、中断规则和对象终结规则 也和这里完全没有关系。
因为 没有一个适用的 先行发生原则,所以最后一条 传递性 也无从谈起,
那怎么修复这个问题呢?
通过上面的例子,我们可以得出结论:
一个操作 “时间上的先发生” 不代表这个操作 会是 “先行发生”,
那如果 一个操作 “先行发生” 是否就能推导 这个操作 必定是 “时间上的先发生” 呢?
讯享网 代码清单 12-10 先行发生原则示例3 ---------------------------------------------------------------------------------------------- // 以下操作在同一个线程中执行 int i = 1; int j = 2; ----------------------------------------------------------------------------------------------
代码清单12-10的 两条赋值语句 在 同一个线程 之中,
根据 程序次序规则, “int i=1” 的操作 先行发生于 “int j=2”,
但是 “int j=2”的代码完全可能先被 处理器 执行,这并不影响 先行发生原则的正确性,因为我们在 这条线程 之中没有办法感知到这点。
上面两个例子综合起来证明了一个结论:时间先后顺序 与 先行发生原则 之间基本没有太大的关系,所以我们衡量 并发安全问题 的时候不要受到 时间顺序的干扰,一切必须以 先行发生原则 为准。
Java与线程
既然我们这本书探讨的话题是 Java虚拟机的特性,那讲到 Java线程,我们就从 Java线程 在 虚拟机中的实现 开始讲起。
线程的实现
在 Java API中,一个 Native 方法 往往意味着 这个方法没有使用 或 无法使用 平台无关的手段来实现(当然也可能是为了 执行效率 而使用 Native 方法, 不过,通常 最高效率的手段 也就是 平台相关的手段)。
正因为如此,作者把本节的标题定为 “线程的实现” 而不是 “Java线程的实现”。
实现线程 主要有3中方式:
使用 内核线程 实现、
使用 用户线程 实现
和使用 用户线程 加 轻量级进程 混合实现。
1.使用内核线程实现
内核线程 (Kernel-Level Thread,KLT) 就是直接由 操作系统内核(Kernel,下称内核)支持的线程,
这种线程 由 内核 来完成 线程切换,
内核 通过操纵 调度器(Scheduler)对 线程 进行 调度 ,
并负责将 线程的任务 映射到各个 处理器 上。
程序 一般不会直接去使用 内核线程,而是去使用 内核线程 的一种高级接口----轻量级进程(Light Weight Process,LWP),
轻量级进程 就是我们通常意义上所讲的 线程,
由于 每个轻量级进程 都有一个 内核线程 支持,因此只有先支持 内核线程,才能有 轻量级进程。
这种 轻量级进程 与 内核线程 之间 1:1的关系 称为 一对一的线程模型,如图12-3所示。
(实活实说,这个图太难了🙃🙃🙃我画不出🙃🙃🙃)
由于 内核线程 的支持,每个 轻量级进程 都成为一个 独立的 调度单元,
即使有一个 轻量级进程 在系统调用中 阻塞了,也不会影响 整个进程继续工作,
但是 轻量级进程 具有它的局限性:
首先,由于是基于 内核线程 实现的,所以各种线程操作,如 创建、析构及同步,都需要进行 系统调用。
而系统调用的代价相对较高,需要在 用户态(User Mode)和内核态(Kernel Mode) 中 来回切换。
其次,每个轻量级进程 都需要有一个 内核线程 的支持,因此 轻量级进程 要消耗一定的 内核资源(如 内核线程 的 栈空间),
因此 一个系统 支持轻量级进程 的 数量 是有限的。
2.使用用户线程实现
而 狭义的 用户线程 指的是 完全建立在 用户空间的 线程库 上,系统内核 不能感知 线程存在的实现。
用户线程 的 建立、同步、销毁和调度 完全在 用户态 中完成,不需要 内核的帮助。
如果程序 实现得当,这种线程 不需要切换到 内核态,因此操作 可以使 非常快速且低消耗的,
也可以支持规模更大的线程数量,部分高性能 数据库中的多线程 就是由 用户线程 实现的。
这种 进程 与 用户线程 之间 1:N 的关系 称为 一对多的线程模型,如图12-4所示。
(不画图了自己去买书看看🙃🙃🙃)
使用 用户线程 的 优势 在于 不需要系统内核支援,劣势 也在于 没有系统内核的支援,所有的 线程操作 都需要 用户程序 自己处理。
(🙃🙃🙃表示像我这种俗人估计一辈子都用不到用户线程以及内核线程,而且估计我用到了我也不知道)
3.使用用户线程加轻量级进程混合实现
线程 除了 依赖 内核线程 实现 和 完全由 用户程序 自己实现 之外,还有一种将 内核线程与用户线程 一起使用的实现方式。
在这种混合实现下,既存在 用户线程,也存在 轻量级进程。
用户线程 还是完全建立在 用户空间 中,因此 用户线程 的 创建、切换、析构等操作依然廉价,并且可以支持 大规模的用户线程并发。
在这种 混合模式中,用户线程和轻量级进程 的数量 是 不定的,即为 N:M 的关系,如图12-5所示,这种就是 多对多的线程模型。
许多 UNIX系列 的 操作系统, 如 Solaris、HP-UX 等都提供了 N:M 的线程模型 实现。
4.Java线程的实现
线程模型 只对 线程的 并发规模和操作成本 产生影响,对Java程序的 编码和运行过程 来说,这些差异都是透明的。
Windows下由 纤程包(Fiber Package),Linux下也有 NGPT(在2.4内核的年代)来实现 N:M 模型,但是他们都没有成为主流。
而在 Solaris平台 中,
由于 操作系统 的 线程特性 可以同时 支持 一对一(通过Bound Threads或Alternate Libthread 实现)及 多对多(通过 LWP/Thread Based Synchronization 实现) 的线程模型,
因此在 Solaris 版的JDK中 也对应提供了 两个平台专有的 虚拟机参数: -XX:+UseLWPSynchronization(默认值) 和 -XX:+UseBoundThreads 来明确指定虚拟机使用哪种 线程模型。
Java线程调度
如果使用 协同式调度的多线程系统,线程的执行时间 由 线程本身 来控制,线程 把 自己的工作执行完了之后,要主动通知 系统 切换到 另外一个线程上。
协同式多线程 的 最大好处 是 实现简单,而且由于 线程要把自己的事情干完后才会进行 线程切换,切换操作 对 线程自己是可知的,所以没有什么 线程同步 的问题。
Lua语言中的 “协同例程” 就是这类实现。
它的 坏处 也很明显:线程执行时间 不可控制,甚至如果一个线程编写 有问题, 一直不告知系统进性 线程切换,那么程序就会 一直阻塞 在那里。
很久以前的 Windows3.x系统 就是使用 协同式 来实现 多进程多任务 的,相当不稳定,一个进程 坚持不让出 CPU 执行时间 就可能导致整个系统 崩溃。
如果使用 抢占式调度的多线程系统,那么 每个线程 将由 系统 来分配 执行时间,线程的切换不由 线程本身 来决定(在Java中,Thread.yield()可以让出执行时间,但是要获取执行时间的话,线程本身是没有什么办法的)。
在JDK后续版本中 有可能会提供 协程(Coroutines)方式 来进行 多任务处理,相关资料可参见:
http://wikis.sum.com/display/mlvm/Coroutines。
与前面所说的 Windows3.x 的例子相对,在 Windows9x/NT 内核中就是使用 抢占式 来实现 多线程的,当一个进程出了问题,我们还可以使用 任务管理器 把这个 进程 “杀掉”,而不至于导致 系统崩溃。
Java语言 一共设置了 10个级别 的 线程优先级( Thread.MIN_PRIORITY 至 Thread.MAX_PRIORITY ),在两个线程同时处于 Ready 状态时,优先级越高的 线程 越容易被 系统 选择执行。
不过,线程优先级 并不是 太靠谱,原因是 Java的线程 是通过 映射到 系统的 原生线程 上来实现的,
所以 线程调度 最终还是取决于 操作系统,虽然现在很多操作系统都提供 线程优先级 的概念,
但是并不见得能与 Java线程的优先级 一一对应,
如Solaris中 有 (2^32)中优先级,但Windows中就只有7中,比Java线程优先级多的系统还好说,中间留下一点空位就可以了,
但比Java线程优先级少的系统,就不得不出现几个 优先级相同的情况了。
| 表 12-1 Java线程优先级与Windows线程优先级之间的对应关系 | |
|---|---|
| Java线程优先级 | Windows线程优先级 |
| 1(Thread.MIN_PRIORITY) | THREAD_PRIORITY_LOWEST |
| 2 | THREAD_PRIORITY_LOWEST |
| 3 | THREAD_PRIORITY_BELOW_NORMAL |
| 4 | THREAD_PRIORITY_BELOW_NORMAL |
| 5 | THREAD_PRIORITY_NORMAL |
| 6 | THREAD_PRIORITY_ABOVE_NORMAL |
| 7 | THREAD_PRIORITY_ABOVE_NORMAL |
| 8 | THREAD_PRIORITY_HIGHEST |
| 9 | THREAD_PRIORITY_HIGHEST |
| 10(Thread.MAX_PRIORITY) | THREAD_PRIORITY_CRITICAL |
上文说到 “线程优先级并不是太靠谱”,不仅仅是说 在一些平台上 不同的优先级 实际会变得相同 这一点,还有其他情况 让我们不能太依赖 优先级:
优先级可能会被 系统 自行改变。
例如,在Windows系统中 存在一个称为 “优先级推进器”(Priority Boosting,当然它可以被关闭掉)的功能,
它的大致作用就是 当系统 发现 一个线程 执行得 特别“勤奋努力”的话,可能会越过 线程优先级 去为它 分配执行时间。
因此,我们不能在程序中 通过 优先级 来完全准确地 判断一组状态都为 Ready的线程 将会先执行哪一个。
状态转换
Java语言 定义了 5中线程状态,在 任意一个时间点, 一个线程只能 有且只有 其中的一种状态,这5种状态分别如下。
新建(New):创建后 尚未启动 的线程 处于这种 状态。
运行(Runnable):Runnable包括了 操作系统 线程状态中的 Running和Ready,也就是处于此状态的 线程 有可能正在执行,也有可能正在等待着 CPU 为它分配执行时间。
- 没有设置 Timeout 参数的 Object.wait() 方法
- 没有设置 Timeout 参数的 Thread.join() 方法
- LockSupport.park() 方法
- Thread.sleep()方法
- 设置了 Timeout 参数的 Object.wait() 方法
- 设置了 Timeout 参数的 Thread.join() 方法
- LockSupport.parkNanos()方法
- LockSupport.parkUtil()方法
阻塞(Blocked):线程被 阻塞 了,
“阻塞状态”与“等待状态” 的区别是:
“阻塞状态”在等待着获取到一个 排他锁,这个事件 将在 另外一个线程 放弃这个锁的时候 发生;
而 “等待状态” 则是在 等待一段时间,或者唤醒动作的发生。
在程序等待进入 同步区域 的时候,线程将进入这种状态。
结束(Terminated):已终止 线程 的 线程状态,线程已经 结束执行。
上述5种状态 在遇到 特定事件 发生的时候 将会 互相转换,它们的 转换关系 如图12-6 所示。
本章小结
本章中,我们首先了解了 虚拟机Java内存模型 的结构及操作,
然后讲解了 原子性、可见性、有序性 在 Java内存模型 中的体现,
最后介绍了 先行发生原则 的规则及使用。
另外,我们还了解了 线程 在 Java语言之中 是如何实现的。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容,请联系我们,一经查实,本站将立刻删除。
如需转载请保留出处:https://51itzy.com/kjqy/78626.html