深入理解JVM：Java内存模型与线程 - 版本历史

Eijux：/* 对于 volatile 型变量的特殊规则 */

2022-11-11T17:05:08Z

对于 volatile 型变量的特殊规则

←上一版本		2022年11月12日 (六) 01:05的版本
第86行：		第86行：
	# '''禁止指令重排序优化（“有序性”）'''：操作 volatile 变量的指令，其前后操作指令有序。<ref>【在其前（后）的操作不能重排序到其之后（前），但前后部分“内”可分别进行重排序】</ref>		# '''禁止指令重排序优化（“有序性”）'''：操作 volatile 变量的指令，其前后操作指令有序。<ref>【在其前（后）的操作不能重排序到其之后（前），但前后部分“内”可分别进行重排序】</ref>
	#* 相当于一个<span style="color: blue">'''内存屏障'''</span>（“Memory Barrier”或“Memory Fence”：重排序时不能把后面的指令重排序到内存屏障之前的位置）；		#* 相当于一个<span style="color: blue">'''内存屏障'''</span>（“Memory Barrier”或“Memory Fence”：重排序时不能把后面的指令重排序到内存屏障之前的位置）；
	#* 应用：利用“volatile”来实现<span style="color: green">“'''DCL（Double Check Lock，双锁检测）单例模式'''”</span>的代码：		#* 应用：利用“volatile”来实现<span style="color: green">“'''DCL（Double Check Lock，双锁检测）单例模式'''”<ref>'''参考：[[设计模式：单例模式]]'''</ref></span>的代码：
	#*: <syntaxhighlight lang="java">		#*: <syntaxhighlight lang="java">
	public class Singleton {		public class Singleton {

Eijux：/* Java与协程 */

2022-11-11T16:52:48Z

Java与协程

←上一版本		2022年11月12日 (六) 00:52的版本
第317行：		第317行：
	12.5.2　协程的复苏		12.5.2　协程的复苏
	12.5.3　Java的解决方案		12.5.3　Java的解决方案

			== 注释 ==
			<references/>

Eijux：/* 对于volatile型变量的特殊规则 */

2022-11-11T16:52:19Z

对于volatile型变量的特殊规则

显示更改

Eijux：/* 针对long和double型变量的特殊规则 */

2022-11-11T15:05:35Z

针对long和double型变量的特殊规则

←上一版本		2022年11月11日 (五) 23:05的版本
第155行：		第155行：
	* 求'''volatile修饰的变量不会被指令重排序优化'''，从而保证代码的执行顺序与程序的顺序相同。【禁止指令重排序】		* 求'''volatile修饰的变量不会被指令重排序优化'''，从而保证代码的执行顺序与程序的顺序相同。【禁止指令重排序】

	=== ~~针对long和double型变量的特殊规则~~ ===		=== 针对 long 和 double 型变量的特殊规则 ===
	<~~pre~~>		Java内存模型要求 lock、unlock、read、load、assign、use、store、write 这八种操作都具有原子性，但是对于 64位的数据类型（long 和 double），在模型中特别定义了一条宽松的规定：允许虚拟机将没有被 volatile 修饰的 64 位数据的读写操作划分为两次 32 位的操作来进行，即允许虚拟机实现自行选择是否要保证 64 位数据类型的 load、store、read 和 write 这四个操作的原子性，这就是所谓的<big>“'''long 和 double的非原子性协定'''”</big>（Non-Atomic Treatment of double and long Variables）。
	Java内存模型要求lock、unlock、read、load、assign、use、store、write这八种操作都具有原子性，但是对于64位的数据类型（long和double），在模型中特别定义了一条宽松的规定：允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行，即允许虚拟机实现自行选择是否要保证64位数据类型的load、store、read和write这四个操作的原子性，这就是所谓的“long和double的非原子性协定”（Non-Atomic Treatment of double and long Variables）。
	~~</pre>~~

	* 目前主流平台下商用的64位Java虚拟机中并不会出现非原子性访问行为，但是对于32位的Java虚拟机，譬如比较常用的32位x86平台下的HotSpot虚拟机，对long类型的数据确实存在非原子性访问的风险。		* 目前主流平台下商用的 64 位 Java 虚拟机中并不会出现非原子性访问行为，但是对于 32 位的 Java 虚拟机（譬如比较常用的 32 位 x86 平台下的 HotSpot 虚拟机），对 long 类型的数据确实存在非原子性访问的风险。
	*: ~~从JDK 9起，HotSpot增加了一个实验性的参数“~~-XX：+~~AlwaysAtomicAccesses”来约束虚拟机对所有数据类型进行原子性的访问。~~		*: 从 JDK 9 起，HotSpot 增加了一个实验性的参数“'''-XX：+AlwaysAtomicAccesses'''”来约束虚拟机对所有数据类型进行原子性的访问。
	* ~~在实际开发中，除非该数据有明确可知的线程竞争，否则不需要因为这个原因刻意把用到的long和double变量专门声明为volatile。~~		* 在实际开发中，除非该数据有明确可知的线程竞争，否则不需要因为这个原因刻意把用到的 long 和 double 变量专门声明为 volatile。

	=== 原子性、可见性与有序性 ===		=== 原子性、可见性与有序性 ===

Eijux：/* 内存间交互操作 */

2022-11-11T14:49:55Z

内存间交互操作

←上一版本		2022年11月11日 (五) 22:49的版本
第45行：		第45行：

	=== 内存间交互操作 ===		=== 内存间交互操作 ===
	~~Java内存模型中定义了以下8种操作来完成：~~		Java 内存模型中定义了以下 8 种操作来完成：
	* ~~Java虚拟机实现时必须保证下面提及的每一种操作都是原子的、不可再分的。~~		* Java 虚拟机实现时必须保证下面提及的每一种操作都是'''原子的'''、不可再分的。
	*:~~（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许有例外）~~		*:（对于 double 和 long 类型的变量来说，load、store、read 和 write 操作在某些平台上允许有例外）

	# ~~lock（锁定）：作用于主内存的变量，它把一个变量标识为一条线程独占的状态。~~		# '''lock'''（锁定）：作用于主内存的变量，它把一个变量标识为一条线程独占的状态。
	# ~~unlock（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。~~		# '''unlock'''（解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
	# ~~read（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用。~~		# '''read'''（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的 load 动作使用。
	# ~~load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。~~		# '''load'''（载入）：作用于工作内存的变量，它把 read 操作从主内存中得到的变量值放入工作内存的变量副本中。
	# use（使用）：作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。		# '''use'''（使用）：作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
	# assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。		# '''assign'''（赋值）：作用于工作内存的变量，它把一个从执行引擎接收的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
	# ~~store（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随后的write操作使用。~~		# '''store'''（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随后的 write 操作使用。
	# ~~write（写入）：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。~~		# '''write'''（写入）：作用于主内存的变量，它把 store 操作从工作内存中得到的变量的值放入主内存的变量中。

	* 如果要把一个变量从主内存拷贝到工作内存，那就要按顺序执行read和load操作；如果要把变量从工作内存同步回主内存，就要按顺序执行store和write操作。（必须按顺序执行，但不要求是连续执行）		* 如果要把一个变量从主内存拷贝到工作内存，那就要按顺序执行 read 和 load 操作；如果要把变量从工作内存同步回主内存，就要按顺序执行 store 和 write 操作。（必须按顺序执行，但不要求是连续执行）

	~~除此之外，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操作）。~~

			除此之外，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程序中哪些内存访问操作在并发下才是安全的。
	*: ~~（以上操作可以简化为read、write、lock和unlock四种）另一种等效判断原则——“~~'''先行发生原则'''”，亦可用来确定一个操作在并发环境下是否安全的。		这 8 种内存访问操作以及上述规则限定，再加上稍后会介绍的专门针对 volatile 的一些特殊规定，就已经能准确地描述出 Java 程序中哪些内存访问操作在并发下才是安全的。
			: （以上操作可以简化为 read、write、lock 和 unlock 四种）另一种等效判断原则——“'''先行发生原则'''”，亦可用来确定一个操作在并发环境下是否安全的。

	=== 对于volatile型变量的特殊规则 ===		=== 对于volatile型变量的特殊规则 ===

Eijux：/* 状态转换 */

2020-10-26T17:07:43Z

状态转换

←上一版本		2020年10月27日 (二) 01:07的版本
第294行：		第294行：

	=== 状态转换 ===		=== 状态转换 ===
			Java语言定义了6种线程状态，在任意一个时间点中，一个线程只能有且只有其中的一种状态，并且可以通过特定的方法在不同状态之间转换：
			# 新建（New）：创建后尚未启动的线程处于这种状态。
			# 运行（Runnable）：包括操作系统线程状态中的Running和Ready，也就是处于此状态的线程有可能正在执行，也有可能正在等待着操作系统为它分配执行时间。
			# 无限期等待（Waiting）：处于这种状态的线程不会被分配处理器执行时间，它们要等待被其他线程显式唤醒。
			#:以下方法会让线程陷入无限期的等待状态：
			#* 没有设置Timeout参数的Object::wait()方法；
			#* 没有设置Timeout参数的Thread::join()方法；
			#* LockSupport::park()方法。
			# 限期等待（Timed Waiting）：处于这种状态的线程也不会被分配处理器执行时间，不过无须等待被其他线程显式唤醒，在一定时间之后它们会由系统自动唤醒。
			#:以下方法会让线程进入限期等待状态：
			#* Thread::sleep()方法；
			#* 设置了Timeout参数的Object::wait()方法；
			#* 设置了Timeout参数的Thread::join()方法；
			#* LockSupport::parkNanos()方法；
			#* LockSupport::parkUntil()方法。
			# 阻塞（Blocked）：线程被阻塞了，
			#:“阻塞状态”与“等待状态”的区别是：
			#*“阻塞状态”在等待着获取到一个'''排它锁'''，这个事件将在另外一个线程放弃这个锁的时候发生；
			#* 而“等待状态”则是在等待一段'''时间，或者唤醒动作'''的发生。在程序等待进入同步区域的时候，线程将进入这种状态。
			# 结束（Terminated）：已终止线程的线程状态，线程已经结束执行。


			[[File:线程状态转换关系.jpg\|600px]]

	== Java与协程 ==		== Java与协程 ==

Eijux：/* Java线程调度 */

2020-10-26T17:00:11Z

Java线程调度

←上一版本		2020年10月27日 (二) 01:00的版本
第276行：		第276行：

	=== Java线程调度 ===		=== Java线程调度 ===
			线程调度是指系统为线程分配处理器使用权的过程，调度主要方式有两种，分别是“协同式”线程调度和“抢占式”线程调度：
			# 协同式（Cooperative Threads-Scheduling）：线程的执行时间由线程本身来控制，线程把自己的工作执行完了之后，要主动通知系统切换到另外一个线程上去。
			#: 实现简单；但线程执行时间不可控制，可能一个线程导致整个进程甚至整个系统阻塞；
			# 抢占式（Preemptive Threads-Scheduling）：每个线程将由系统来分配执行时间，线程的切换不由线程本身来决定。
			#: Java使用的线程调度方式就是抢占式调度。


			线程优先级：
			Java语言一共设置了10个级别的线程优先级（Thread.MIN_PRIORITY至Thread.MAX_PRIORITY）。在两个线程同时处于Ready状态时，优先级越高的线程越容易被系统选择执行。
			* 因为主流虚拟机上的Java线程是被映射到系统的原生线程上来实现的，线程优先级亦是如此，所以线程调度最终还是由操作系统说了算。
			* 优先级可能会被系统自行改变，所以不能通过优先级来完全准确判断一组状态都为Ready的线程将会先执行哪一个。


			Java线程优先级与Windows线程优先级之间的对应关系：
			:[[File:Java线程优先级与Windows线程优先级之间的对应关系1.jpg\|600px]]
			:[[File:Java线程优先级与Windows线程优先级之间的对应关系2.jpg\|600px]]

	=== 状态转换 ===		=== 状态转换 ===

Eijux：/* 线程的实现 */

2020-10-26T16:49:21Z

线程的实现

←上一版本		2020年10月27日 (二) 00:49的版本
第221行：		第221行：
	# 使用用户线程实现（1：N实现），		# 使用用户线程实现（1：N实现），
	# 使用用户线程加轻量级进程混合实现（N：M实现）。		# 使用用户线程加轻量级进程混合实现（N：M实现）。

			【这部分以前在计算机基础学过？？？看看去】

	==== 内核线程实现 ====		==== 内核线程实现 ====

Eijux：/* Java与线程 */

2020-10-26T16:47:56Z

Java与线程

@@ 第216行： / 第216行： @@
 === 线程的实现 ===
 === Java线程调度 ===
 === 状态转换 ===
 == Java与协程 ==

Eijux：/* 先行发生原则 */

2020-10-26T14:02:51Z

先行发生原则

@@ 第181行： / 第181行： @@
 * “synchronized”关键字在需要这三种特性的时候都可以作为其中一种的解决方案。
-=== 先行发生原则 ===
+=== 先行发生原则（Happens-Before）===
 == Java与线程 ==

深入理解JVM：Java内存模型与线程 - 版本历史

Eijux：​/* 对于 volatile 型变量的特殊规则 */

Eijux：​/* Java与协程 */

Eijux：​/* 对于volatile型变量的特殊规则 */

Eijux：​/* 针对long和double型变量的特殊规则 */

Eijux：​/* 内存间交互操作 */

Eijux：​/* 状态转换 */

Eijux：​/* Java线程调度 */

Eijux：​/* 线程的实现 */

Eijux：​/* Java与线程 */

Eijux：​/* 先行发生原则 */