文章首发于 www.exception.site
前言
![640?wx_fmt=jpeg](https://i-blog.csdnimg.cn/blog_migrate/a42d77cef644bbb187dca4c16cf872a4.jpeg)
在高并发实际场景下,volatile
关键字应用较多,同时,这也是面试的必问的一个知识点了。那么,valatile
关键字有什么作用呢?
内存可见性
这需要从 Java 的内存模型(JMM
)说起,JMM
规定所有的变量都需要存放在主内存中,同时,每个线程又有着自己的工作内存 (主要做高速缓存)。
这样,线程工作时需要操作变量时,需要将主内存中的数据拷贝到工作内存中。这样线程对数据的任何操作都是基于线程本身的工作内存(目的是为了提升效率),而不能去直接操作主内存以及其他线程的工作内存的数据,当线程对数据做了更新以后,还需要将更新后的数据刷新到主内存中。
![640?wx_fmt=jpeg](https://i-blog.csdnimg.cn/blog_migrate/edacd97aeea80f8a5c5f6399204215a8.jpeg)
以上图为例,在并发情况下,可能会出现线程 B 读取到的数据是线程 A 更新之前的数据,从而导致数据不一致。
这个时候,就需要 volatile 出场了:
当一个变量被 volatile 修饰的时候,任何线程对其做的写操作都会被立即刷新到主内存中,并且强制让那些缓存了该变量的线程内的该变量数据清空,需要从主内存中重新读取最新数据。
注意:volatile 修饰的变量,并不是让线程直接操作主内存获取数据,还是需要将变量拷贝到工作内存中。
volidate 应用 demo
我们模拟一个简单的应用场景,两个线程需要同时访问主内存中的某个标志位变量 flag
, 我们用 volidate
来修饰:
public class VolatileRunnable implements Runnable{
private static volatile boolean flag = true ;
@Override
public void run() {
while (flag) {
System.out.println(Thread.currentThread().getName()+ "正在运行。。。");
}
System.out.println(Thread.currentThread().getName()+ "执行完毕。。。");
}
public static void main(String[] args) throws InterruptedException {
VolatileRunable vr = new VolatileRunable();
new Thread(vr,"thread A").start();
System.out.println("main 线程正在运行") ;
TimeUnit.MILLISECONDS.sleep(100) ;
vr.stopThread();}
private void stopThread(){
flag = false ;
}
}
主线程在对 flag 做了修改以后,flag 会立马被刷新到主内存中,从而及时停止线程 A, 如果说 flag 没有被 volidate 修饰,就可能会出现延迟。
volidate 一定能保证线程的安全性吗?
上面说到的 volidate 能够保证被修改的变量及时被刷新到主内存中,很多人会认为这样就能保证线程的安全性。
答案是否定的。volidate 并不能保证线程的安全性!
public class VolatileInc implements Runnable{
private static volatile int count = 0 ; // 使用 volatile 修饰基本数据内存不能保证原子性
//private static AtomicInteger count = new AtomicInteger() ;
@Override
public void run() {
for (int i=0;i<10000 ;i++){
count ++ ;
//count.incrementAndGet();}
}
public static void main(String[] args) throws InterruptedException {
VolatileInc volatileInc = new VolatileInc() ;
Thread t1 = new Thread(volatileInc,"t1") ;
Thread t2 = new Thread(volatileInc,"t2") ;
t1.start();
//t1.join();
t2.start();
//t2.join();
for (int i=0;i<10000 ;i++){
count ++ ;
//count.incrementAndGet();}
System.out.println("最终 Count="+count);
}
}
上面这段代码中,三个线程对 int i
进行累加,最终的结果都会小于 30000,而不是刚好 30000!
这是什么情况?不是说 volidate 保证了内存的可见性吗?
volidate 固然保证了内存的可见性,使得每个线程都能拿到最新的值,但是 count ++ 这个操作并不是原子的,看似简单的自增加 1 的操作,实际上包含了三个操作:
获取值;
自增;
赋值;
但这三个操作没有原子性,并不能同时完成。
那要如何解决对没有原子性的基本数据的并发安全性呢?
1.用单线程串行执行(不推荐,无法充分发挥多核 CPU 的优势);
2.通过
synchronize
对数据上锁保证原子性;3.通过
Atomic
包中的 AtomicInteger 来替换int
, 它的底层利用了CAS
算法来保证原子性
validate 之指令重排
validate
除了能够保证内存的可见性,它的另一重作用是防止 JVM 进行指令重排优化。
用代码说事:
int a=1 ; // 1
int b=2 ; // 2
int c= a+b ; // 3
上面是一段基础代码,理想情况下它的执行顺序是:1 ==> 2 ==> 3
。但是在 JVM 对其进行指令重排优化后,它的执行顺序可能变为: 2 ==> 1 ==> 3
.
JVM 的指令重排优化是在保证最终结果不变的情况下进行的。
上面的代码还看不出指令重排对实际业务带来的影响,看下面的代码:
private static Map<String,String> value ;
private static volatile boolean flag = fasle ;
// 以下方法发生在线程 A 中 初始化 Map
public void initMap() {
// 耗时操作
value = getMapValue() ; // 1
flag = true ; // 2
}
// 发生在线程 B 中 等到 Map 初始化成功进行其他操作
public void doSomeThing() {
while(!flag) {
sleep();}
// dosomething
doSomeThing(value);
}
如果上面的 flag
变量没被 volidate
修饰的话,JVM 指令重排优化后,导致 value
还没有被初始化,就有可能被线程 B 使用了。
这里加上 volidate 之后可以保证业务的正确性。
volidate 防指令重排应用
比较经典的应用场景就是双重懒加载的单例模式了:
public class Singleton {
private static volatile Singleton singleton;
private Singleton(){}
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
// 防止指令重排
singleton = new Singleton();}
}
}
return singleton;
}
}
上面对 Singleton
对象添加 volatile
关键字,就是为了防止指令重排。
如果说我们不使用的话,singleton = new Singleton();
,这段代码其实是分为三步:
第一步:分配内存空间
第二步:初始化对象
第三步:将
singleton
对象指向分配的内存地址
加上 volidate
保证上面三步得以顺序执行,否则可能出现 第二步 在 第三步 之前执行的情况发生,就可能导致某个线程拿到的单例对象是还没有被初始化,导致程序报错。
总结
volatile 在 Java 并发应用场景有很多,比如像 Atomic
包中的 value
、以及 AbstractQueuedLongSynchronizer
中的 state
都是被定义为 volatile
来用于保证内存可见性。
将这块理解透彻对我们编写并发程序时将获益匪浅。