java 并发编程之共享变量的实现方法

可见性

如果一个线程对共享变量值的修改, 能够及时的被其他线程看到, 叫做共享变量的可见性.

Java 虚拟机规范试图定义一种 Java 内存模型 (JMM), 来屏蔽掉各种硬件和操作系统的内存访问差异, 让 Java 程序在各种平台上都能达到一致的内存访问效果.

简单来说, 由于 CPU 执行指令的速度是很快的, 但是内存访问的速度就慢了很多, 相差的不是一个数量级, 所以搞处理器的那群大佬们又在 CPU 里加了好几层高速缓存.

在 Java 内存模型里, 对上述的优化又进行了一波抽象. JMM 规定所有变量都是存在主存中的, 类似于上面提到的普通内存, 每个线程又包含自己的工作内存, 方便理解就可以看成 CPU 上的寄存器或者高速缓存.

所以线程的操作都是以工作内存为主, 它们只能访问自己的工作内存, 且工作前后都要把值在同步回主内存.

简单点就是, 多线程中读取或修改共享变量时, 首先会读取这个变量到自己的工作内存中成为一个副本, 对这个副本进行改动后, 再更新回主内存中.

使用工作内存和主存, 虽然加快的速度, 但是也带来了一些问题. 比如看下面一个例子:

i = i + 1;

假设 i 初值为 0, 当只有一个线程执行它时, 结果肯定得到 1, 当两个线程执行时, 会得到结果 2 吗? 这倒不一定了. 可能存在这种情况:

线程1： load i from 主存  // i = 0
    i + 1 // i = 1
线程2： load i from主存 // 因为线程1还没将i的值写回主内存，所以i还是0
    i + 1 //i = 1
线程1: save i to 主存
线程2： save i to 主存

如果两个线程按照上面的执行流程, 那么 i 最后的值居然是 1 了. 如果最后的写回生效的慢, 你再读取 i 的值, 都可能是 0, 这就是缓存不一致问题.

这种情况一般称为 失效数据, 因为线程1 还没将 i 的值写回主内存, 所以 i 还是 0, 在线程2 中读到的就是 i 的失效值(旧值).

也可以理解成, 在操作完成之后将工作内存中的副本回写到主内存, 并且在其它线程从主内存将变量同步回自己的工作内存之前, 共享变量的改变对其是不可见的.

有序性

有序性: 即程序执行的顺序按照代码的先后顺序执行. 举个简单的例子, 看下面这段代码:

int i = 0;
boolean flag = false;
i = 1;        //语句1
flag = true;     //语句2

上面代码定义了一个 int 型变量, 定义了一个 boolean 类型变量, 然后分别对两个变量进行赋值操作.

从代码顺序上看, 语句1 是在语句2 前面的, 那么 JVM 在真正执行这段代码的时候会保证语句1 一定会在语句2 前面执行吗？ 不一定, 为什么呢？ 这里可能会发生指令重排序.

重排序

指令重排是指 JVM 在编译 Java 代码的时候, 或者 CPU 在执行 JVM 字节码的时候, 对现有的指令顺序进行重新排序.

它不保证程序中各个语句的执行先后顺序同代码中的顺序一致, 但是它会保证程序最终执行结果和代码顺序执行的结果是一致的(指的是不改变单线程下的程序执行结果).

虽然处理器会对指令进行重排序, 但是它会保证程序最终结果会和代码顺序执行结果相同, 那么它靠什么保证的呢？ 再看下面一个例子:

int a = 10;  //语句1
int r = 2;  //语句2
a = a + 3;  //语句3
r = a*a;   //语句4

这段代码有 4 个语句, 那么可能的一个执行顺序是:

那么可不可能是这个执行顺序呢?

语句2 语句1 语句4 语句3.

不可能, 因为处理器在进行重排序时是会考虑指令之间的数据依赖性, 如果一个指令 Instruction 2 必须用到 Instruction 1 的结果, 那么处理器会保证 Instruction 1 会在 Instruction 2 之前执行.

虽然重排序不会影响单个线程内程序执行的结果, 但是多线程呢? 下面看一个例子:

//线程1:
context = loadContext();  //语句1
inited = true;       //语句2

//线程2:
while(!inited ){
 sleep()
}
doSomethingwithconfig(context);

上面代码中, 由于语句1 和语句2 没有数据依赖性, 因此可能会被重排序.

假如发生了重排序, 在线程1 执行过程中先执行语句2, 而此时线程2 会以为初始化工作已经完成, 那么就会跳出 while 循环, 去执行 doSomethingwithconfig(context) 方法, 而此时 context 并没有被初始化, 就会导致程序出错.

从上面可以看出, 指令重排序不会影响单个线程的执行, 但是会影响到线程并发执行的正确性.

原子性

Java 中, 对基本数据类型的读取和赋值操作是原子性操作, 所谓原子性操作就是指这些操作是不可中断的, 要做一定做完, 要么就没有执行.

JMM 只实现了基本的原子性, 像 i++ 的操作, 必须借助于 synchronized 和 Lock 来保证整块代码的原子性了. 线程在释放锁之前, 必然会把 i 的值刷回到主存的.

重点, 要想并发程序正确地执行, 必须要保证原子性、可见性以及有序性. 只要有一个没有被保证, 就有可能会导致程序运行不正确.

volatile 关键字

volatile 关键字的两层语义

一旦一个共享变量 (类的成员变量、类的静态成员变量) 被 volatile 修饰之后, 那么就具备了两层语义:

1) 禁止进行指令重排序.

2) 读写一个变量时, 都是直接操作主内存.

在一个变量被 volatile 修饰后, JVM 会为我们做两件事:

1.在每个 volatile 写操作前插入 StoreStore 屏障, 在写操作后插入 StoreLoad 屏障.

2.在每个 volatile 读操作前插入 LoadLoad 屏障, 在读操作后插入 LoadStore 屏障.

或许这样说有些抽象, 我们看一看刚才线程A代码的例子:

boolean contextReady = false;

//在线程A中执行:
context = loadContext();
contextReady = true;

我们给 contextReady 增加 volatile 修饰符, 会带来什么效果呢?

由于加入了 StoreStore 屏障, 屏障上方的普通写入语句 context = loadContext() 和屏障下方的 volatile 写入语句 contextReady = true 无法交换顺序, 从而成功阻止了指令重排序.

也就是说, 当程序执行到 volatile 变量的读或写操作时, 在其前面的操作的更改肯定全部已经进行, 且结果已经对后面的操作可见.

volatile特性之一:
保证变量在线程之间的可见性. 可见性的保证是基于 CPU 的内存屏障指令, 被 JSR-133 抽象为 happens-before 原则.

volatile特性之二:
阻止编译时和运行时的指令重排. 编译时 JVM 编译器遵循内存屏障的约束, 运行时依靠 CPU 屏障指令来阻止重排.

volatile 除了保证可见性和有序性, 还解决了 long 类型和 double 类型数据的 8 字节赋值问题.
虚拟机规范中允许对 64 位数据类型, 分为 2 次 32 位的操作来处理, 当读取一个非 volatile 类型的 long 变量时, 如果对该变量的读操作和写操作不在同一个线程中执行, 那么很有可能会读取到某个值得高 32 位和另一个值得低 32 位.

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。