一起学并发编程 - Volatile关键字详解

文章目录
  1. 1. 概述
    1. 1.1. 示例 - 非Volatile
    2. 1.2. 示例 - Volatile
  2. 2. Happens-Before 原则
  3. 3. 总结适用场景
  4. 4. - 说点什么

volatile是用来标记一个JAVA变量存储在主内存(main memory)中,确切的说:每次写操作volatile变量时,将直接从电脑的主内存(main memory)中读取操作而不是从CPU Cache

概述

可见性: 是指线程之间数据可见共享,一个线程修改的状态对另一个线程是可见的。比如:用volatile修饰的变量,就会确保变量在修改时,其它线程是可见的。。

在多线程中,对非volatile变量进行操作的时候,出于对性能的考虑,当对这些变量进行数据操作时,线程可能会从主内存里拷贝变量到CPU Cache中去。多核CPU环境中,多个线程分别在不同的CPU中运行,就意味着,多个线程都有可能将变量拷贝到当前运行的CPU Cache里。

如下图所示(多线程数据模型):

多线程数据模型

示例 - 非Volatile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class NotSharedObject {

private static int COUNTER = 0;
private static final int MAX_LIMIT = 5;

public static void main(String[] args) {
new Thread(() -> {
int localValue = COUNTER;
while (localValue < MAX_LIMIT) {
if (localValue != COUNTER) {
System.out.printf("[线程] - [%s] - [%d]\n", Thread.currentThread().getName(), COUNTER);
localValue = COUNTER;
}
}
}, "READER").start();

new Thread(() -> {
int localValue = COUNTER;
while (COUNTER < MAX_LIMIT) {
System.out.printf("[线程] - [%s] - [%d]\n", Thread.currentThread().getName(), ++localValue);
COUNTER = localValue;
}
}, "UPDATER").start();
}
}
1
2
3
4
5
[线程] - [UPDATER] - [1]
[线程] - [UPDATER] - [2]
[线程] - [UPDATER] - [3]
[线程] - [UPDATER] - [4]
[线程] - [UPDATER] - [5]
  • 结果表明,UPDATE线程虽修改数据,但是READER线程并未监听到数据的变动,当前线程操作的是当前CPU Cache里的数据,而不是从main memory获取的。
  • couner 的变量未使用volatile关键字修饰即JVM无法保证有效的将CPU Cache的内容写入主存中。意味着 counter 变量在CPU Cache中的值可能会与主存中的值不一样。

如下图所示(无Volatile):

无Volatile

示例 - Volatile

1
2
3
4
5
6
7
8
9
10
private static volatile int COUNTER = 0;


[线程] - [UPDATER] - [1]
[线程] - [UPDATER] - [2]
[线程] - [READER] - [1]
[线程] - [UPDATER] - [3]
[线程] - [UPDATER] - [4]
[线程] - [UPDATER] - [5]
[线程] - [READER] - [3]
  • 结果表明,volatile修饰后的变量并不会达到Lock的效果,它只会保证线程可见性,但不保证原子性,在读取volatile变量和写入它的新值时,由于操作耗时较短,就会产生 竞争条件:多个线程可能会读取到volatile变量的相同值,然后产生新值并写入主内存,这样将会覆盖互相的值。(有兴趣的可以在创建一个UPDATE线程测试效果)

如下图所示(Volatile):

有Volatile

Happens-Before 原则

Java5之后volatile关键字不仅能用于保证变量从主存中进行读写操作,同时还遵循Happens-Before原则,下文将会描述存在于volatile中的一些细节,想深入的可以自行谷歌 happens-before relationship或者访问提供的几个链接

参考文献(1):https://en.wikipedia.org/wiki/Happened-before

参考文献(2):http://preshing.com/20130702/the-happens-before-relation/

参考文献(3):http://www.importnew.com/17149.html

  • 如果T1线程写入了一个volatile变量然后T2线程读取该变量,那么T1线程写之前对其可见的所有变量,T2线程读取该volatile之后也会对其可见。
  • 禁止JVM指令重排优化,一旦被volatile修饰的变量,赋值后多执行了一个load addl $0x0, (%esp)操作,相当于多了一个内存屏障(指令重排序时不能把后面的指令重排序到内存屏障之前的位置),单核CPU访问内存时,并不需要内存屏障;

看看下面这个示例:

1
2
3
4
5
6
7
8
9
10
11
T1线程:
Object obj;
volatile boolean init;
---------T1线程------------
obj = createObj() 1;
init = true; 2;
---------T2线程------------
while(!init){
sleep();
}
useTheObj(obj);

  • volatile修饰过的变量 init在写操作之前,创建了非volatile变量的obj,因而T1线程在写入init后,会将obj也写入主内存中去。
  • 由于T2线程启动的时候读取被volatile修饰过的init,因而变量 init 和变量 obj 都会被写入T2线程所使用的CPU缓存中去。当T2线程读取 obj 变量时,它将能看见被T1线程写入的东西。

总结适用场景

  • 线程可见,状态量标记
1
2
3
4
5
6
7
8
volatile boolean start = true;

while(start){
//
}
void close(){
start = false;
}
  • 屏障前后一致性,禁止指令重排

- 说点什么

全文代码:https://gitee.com/battcn/battcn-concurent/tree/master/Chapter1-1/battcn-thread/src/main/java/com/battcn/chapter13

  • 个人QQ:1837307557
  • battcn开源群(适合新手):391619659

微信公众号:battcn(欢迎调戏)