总结:
1、volatile变量没有真正独立于其他变量和自己以前的值时,volatile无法保证原子性,此时可以使用synchronized和ReentrantLock来解决原子性问题
2、volatile变量真正独立于其他变量和自己以前的值时可以使用 volatile 代替 synchronized 来优化代码提升效率
synchronized和volatile比较
a)volatile不需要加锁,比synchronized更轻便,不会阻塞线程。
b)synchronized既能保证可见性,又能保证原子性,而volatile只能保证可见性,无法保证原子性。
volatile解决内存可见性的使用
通过前面内容我们了解了synchronized,虽然JVM对它做了很多优化,但是它还是一个重量级的锁。而接下来要介绍的volatile则是轻量级的synchronized。如果一个变量使用volatile,则它比使用synchronized的成本更加低,因为它不会引起线程上下文的切换和调度。
Java语言规范对volatile的定义如下:
Java允许线程访问共享变量,为了确保共享变量能被准确和一致地更新,线程应该确保通过排他锁单独获得这个变量。
通俗点讲就是说一个变量如果用volatile修饰了,则Java可以确保所有线程看到这个变量的值是一致的,如果某个线程对volatile修饰的共享变量进行更新,那么其他线程可以立马看到这个更新,这就是内存可见性。
Java中的volatile
关键字提供了一个功能,那就是被其修饰的变量在被修改后可以立即同步到主内存,被其修饰的变量在每次是用之前都从主内存刷新。因此,可以使用volatile
来保证多线程操作时变量的可见性。
volatile虽然看起来比较简单,使用起来无非就是在一个变量前面加上volatile即可,但是要用好并不容易。
解决内存可见性问题
在可见性问题案例中进行如下修改,添加volatile关键词:
private volatile boolean flag = true;
public class Demo1Jmm { public static void main(String[] args) throws InterruptedException { JmmDemo demo = new JmmDemo(); Thread t = new Thread(demo); t.start(); Thread.sleep(100); demo.flag = false; System.out.println("已经修改为false"); System.out.println(demo.flag); } static class JmmDemo implements Runnable { public volatile boolean flag = true; public void run() { System.out.println("子线程执行。。。"); while (flag) { } System.out.println("子线程结束。。。"); } } }
执行结果:
Volatile实现内存可见性的过程
线程写Volatile变量的过程:
1. 改变线程本地内存中Volatile变量副本的值;
2. 将改变后的副本的值从本地内存刷新到主内存
线程读Volatile变量的过程:
1. 从主内存中读取Volatile变量的最新值到线程的本地内存中
2. 从本地内存中读取Volatile变量的副本
Volatile实现内存可见性原理:
写操作时,通过在写操作指令后加入一条store屏障指令,让本地内存中变量的值能够刷新到主内存中
读操作时,通过在读操作前加入一条load屏障指令,及时读取到变量在主内存的值
PS: 内存屏障(Memory Barrier)是一种CPU指令,用于控制特定条件下的重排序和内存可见性问题。Java编译器也会根据内存屏障的规则禁止重排序
volatile的底层实现是通过插入内存屏障,但是对于编译器来说,发现一个最优布置来最小化插入内存屏障的总数几乎是不可能的,所以,JMM采用了保守策略。如下:
1、StoreStore屏障可以保证在volatile写之前,其前面的所有普通写操作都已经刷新到主内存中。
2、StoreLoad屏障的作用是避免volatile写与后面可能有的volatile读/写操作重排序。
3、LoadLoad屏障用来禁止处理器把上面的volatile读与下面的普通读重排序。
4、LoadStore屏障用来禁止处理器把上面的volatile读与下面的普通写重排序。
原子性的问题
public class Demo3Volatile { public static void main(String[] args) throws InterruptedException { VolatileDemo demo = new VolatileDemo(); for (int i = 0; i < 5; i++) { Thread t = new Thread(demo); t.start(); } Thread.sleep(1000); System.out.println(demo.count); } static class VolatileDemo implements Runnable { public volatile int count; //public volatile AtomicInteger count = new AtomicInteger(0); public void run() { addCount(); } public void addCount() { for (int i = 0; i < 10000; i++) { count++; } } } }
执行结果为:42201
1. 线程1读取count的值为5
2. 线程2读取count的值为5
3. 线程2加1操作
4. 线程2最新count的值为6
5. 线程2写入值到主内存的最新值为6
这个时候,线程1的count为5,线程2的count为6,如果切换到线程1执行(+1),那么线程1得到的结果是6,写入到主内存的值还是6。现在的情况是对count进行了两次加1操作,但是主内存实际上只是加1一次。即线程2在执行的时候,被线程1打断,线程1也执行了。
volatile无法保证原子性的解决方案:
1. 使用synchronized
2. 使用ReentrantLock(可重入锁)
3. 使用AtomicInteger(原子操作)
public class Demo3Volatile { public static void main(String[] args) throws InterruptedException { VolatileDemo demo = new VolatileDemo(); for (int i = 0; i < 5; i++) { Thread t = new Thread(demo); t.start(); } Thread.sleep(1000); System.out.println(demo.count); } static class VolatileDemo implements Runnable { public volatile int count; //public volatile AtomicInteger count = new AtomicInteger(0); public void run() { addCount(); } public synchronized void addCount() { for (int i = 0; i < 10000; i++) { count++; } } } }
执行结果为50000
public class Demo3Volatile {
public static void main(String[] args) throws InterruptedException {
VolatileDemo demo = new VolatileDemo();
for (int i = 0; i < 5; i++) {
Thread t = new Thread(demo);
t.start();
}
Thread.sleep(1000);
System.out.println(demo.count);
}
static class VolatileDemo implements Runnable {
public volatile int count;
// public volatile AtomicInteger count = new AtomicInteger(0);
public void run() {
addCount();
}
private Lock lock = new ReentrantLock();
public void addCount() {
for (int i = 0; i < 10000; i++) {
lock.lock();
try {
count++;
}finally {
lock.unlock();
}
}
}
}
}
Volatile 适合使用场景
a)对变量的写入操作不依赖其当前值
不满足:number++、count=count*5等
满足:boolean变量、直接赋值的变量等
b)该变量没有包含在具有其他变量的不变式中
不满足:不变式 low<up
总结:变量真正独立于其他变量和自己以前的值,在单独使用的时候,适合用volatile