详解volatile 关键字与内存可见性

先来看一个例子：

public class VolatileTest {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
new Thread(td).start();
while (true) {
if (td.isFlag()) {
System.out.println("================");
break;
}
}
}
}
class ThreadDemo implements Runnable {
private boolean flag = false;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
}
flag = true;
System.out.println("falg=" + flag);
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}

两个线程，一个改flag的值，主线程做判断，结果：

主线程的flag貌似还是false，按理通过Runnable创建的线程访问的应该是共享数据，那为什么会出现这种情况？这就涉及到内存可见性。

JVM会为每个线程分配一个独立缓存提高效率。上述例子中我们先在主存中开辟一块内存，如图：

那么这个两个线程，一个是读(主线程)，一个是写(线程1)，我们让线程1睡了200ms，说明，线程1先执行，每个线程都有一个独立的缓存，也就是说当线程1需要对主存的共享数值进行改变，它需要先把这个flag复制一份到缓存区中，

然后修改，将来再把这个值写回主存去，在写之前，主线程来了，它要读取现在在内存里面的值，现在是false，当然有一种情况，就是线程1在某个机会将flag=true写回去，

当时主线程用了while(true)，这句话调用了系统底层代码，效率极高，高到主线程没有机会再次读取内存，这就是线程对共享数据操作的不可见。

内存可见性问题：当多个线程操作共享数据时，彼此不可见。

如何解决？同步锁。

但是用了锁，代表效率极低，但是我现在我不想加锁，但是有存在内存可见性的问题，我该怎么办？

关键字volatile：当多个线程进行操作共享操作时，可以保证内存中的数据可见。(内存栅栏，实时刷新)

我们可以认为它是直接在主存操作的，这个实时刷新的操作相比不加，性能略低，但是比加锁的效率显然高很多，低在哪？加了这关键字，JVM就不能进行指令重排序，无法优化代码执行。

public class VolatileTest {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
new Thread(td).start();
while (true) {
if (td.isFlag()) {
System.out.println("================");
break;
}
}
}
}
class ThreadDemo implements Runnable {
private volatile boolean flag = false;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
}
flag = true;
System.out.println("falg=" + flag);
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}

volatile相对synchronized是一种轻量级同步策略。但是注意：

volatile不具备互斥性
volatile不能保证变量的原子性

__EOF__

本文作者：FigSprite
本文链接：https://www.cnblogs.com/figsprite/p/10779904.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！