Java 中 volatile 关键字是一个类型修饰符。JDK 1.5 之后,对其语义进行了增强。

  • 保证了不同线程对共享变量进行操作时的可见性,即一个线程修改了共享变量的值,共享变量修改后的值对其他线程立即可见

  • 通过禁止编译器、CPU 指令重排序和部分 happens-before 规则,解决有序性问题

 

volatile 可见性的实现

  • 在生成汇编代码指令时会在 volatile 修饰的共享变量进行写操作的时候会多出 Lock 前缀的指令

  • Lock 前缀的指令会引起 CPU 缓存写回内存

  • 一个 CPU 的缓存回写到内存会导致其他 CPU 缓存了该内存地址的数据无效

  • volatile 变量通过缓存一致性协议保证每个线程获得最新值

  • 缓存一致性协议保证每个 CPU 通过嗅探在总线上传播的数据来检查自己缓存的值是不是修改

  • 当 CPU 发现自己缓存行对应的内存地址被修改,会将当前 CPU 的缓存行设置成无效状态,重新从内存中把数据读到 CPU 缓存

 

看一下我们之前的一个可见性问题的测试例子

package constxiong.concurrency.a014;

/**
* 测试可见性问题
* @author ConstXiong
*/

public class TestVisibility {

//是否停止 变量
private static boolean stop = false;

public static void main(String[] args) throws InterruptedException {
//启动线程 1,当 stop 为 true,结束循环
new Thread(() -> {
   System.out.println("线程 1 正在运行...");
   while (!stop) ;
   System.out.println("线程 1 终止");
}).start();

//休眠 10 毫秒
Thread.sleep(10);

//启动线程 2, 设置 stop = true
new Thread(() -> {
   System.out.println("线程 2 正在运行...");
   stop = true;
   System.out.println("设置 stop 变量为 true.");
}).start();
}

}

程序会一直循环运行下去

图片

这个就是因为 CPU 缓存导致的可见性导致的问题。

线程 2 设置 stop 变量为 true,线程 1 在 CPU 1上执行,读取的 CPU 1 缓存中的 stop 变量仍然为 false,线程 1 一直在循环执行。

示意如图:

图片

 

给 stop 变量加上 valatile 关键字修饰就可以解决这个问题。

 

volatile 有序性的实现

  • 3 个 happens-before 规则实现:

1) 对一个 volatile 变量的写 happens-before 任意后续对这个 volatile 变量的读

2) 在一个线程内,按照程序代码顺序,书写在前面的操作先行发生于书写在后面的操作

3) happens-before 传递性,A happens-before B,B happens-before C,则 A happens-before C

 

  • 内存屏障(Memory Barrier 又称内存栅栏,是一个 CPU 指令)禁止重排序

1) 在程序运行时,为了提高执行性能,在不改变正确语义的前提下,编译器和 CPU 会对指令序列进行重排序。

2) Java 编译器会在生成指令时,为了保证在不同的编译器和 CPU 上有相同的结果,通过插入特定类型的内存屏障来禁止特定类型的指令重排序

3) 编译器根据具体的底层体系架构,将这些内存屏障替换成具体的 CPU 指令

4) 内存屏障会告诉编译器和 CPU:不管什么指令都不能和这条 Memory Barrier 指令重排序

 

内存屏障

  • 为了实现 volatile 内存语义时,编译器在生成字节码时,会在指令序列中插入内存屏障来禁止特定类型的 CPU 重排序。

  • 对于编译器,内存屏障将限制它所能做的重排序优化;对于 CPU,内存屏障将会导致缓存的刷新操作

  • volatile 变量的写操作,在变量的前面和后面分别插入内存屏障;volatile 变量的读操作是在后面插入两个内存屏障

1) 在每个 volatile 写操作的前面插入一个 StoreStore 屏障
2) 在每个 volatile 写操作的后面插入一个 StoreLoad 屏障
3) 在每个 volatile 读操作的后面插入一个 LoadLoad 屏障
4) 在每个 volatile 读操作的后面插入一个 LoadStore 屏障

  • 屏障说明

1) StoreStore:禁止之前的普通写和之后的 volatile 写重排序;
2) StoreLoad:禁止之前的 volatile 写与之后的 volatile 读/写重排序
3) LoadLoad:禁止之后所有的普通读操作和之前的 volatile 读重排序
4) LoadStore:禁止之后所有的普通写操作和之前的 volatile 读重排序

 

我觉得,有序性最经典的例子就是 JDK 并发包中的显式锁 java.util.concurrent.locks.Lock 的实现类对有序性的保障。

 

以下摘自:

https://ifeve.com/java锁是如何保证数据可见性的/


实现 Lock 的代码思路简化为

private volatile int state;

void lock() {
   read state
   if (can get lock)
       write state
}

void unlock() {
   write state
}
  • 假设线程 a 通过调用lock方法获取到锁,此时线程 b 也调用了 lock() 方法,因为 a 尚未释放锁,b 只能等待。

  • a 在获取锁的过程中会先读 state,再写 state。

  • 当 a 释放掉锁并唤醒 b,b 会尝试获取锁,也会先读 state,再写 state。

Happens-before 规则:一个 volatile 变量的写操作发生在这个 volatile 变量随后的读操作之前。


更多相关文章

  1. 什么是守护线程?
  2. 如何优雅地停止一个线程?
  3. java多线程(11)AtomicBoolean原子类分析
  4. Java基础系列:线程同步和线程池
  5. java多线程(6)sleep和wait的4大区别
  6. java多线程(5)多线程通信出现的假死现象分析
  7. java多线程(4)使用wait/notify机制进行单线程之间的通信
  8. java多线程(3)Thread构造函数解析
  9. java多线程(2)线程生命周期和常见API

随机推荐

  1. Android应用程序资源管理器
  2. Android com.android.support 版本不一致
  3. android进度对话框的使用
  4. android一些不常用的事件
  5. Android第二十六课 调试模式 file.exits
  6. 2018-09-20~2018-09-21 Google Developer
  7. android性能优化-渲染-嵌套标签
  8. Android 网络链接,不要忘记添加网络权限。
  9. Android 屏保源码
  10. RxJava使用(一)基本使用