volatile修饰符
1.简述
volatile是Java提供的一种轻量级的同步机制。Java语言包含两种内在的同步机制:同步块(或方法)和volatile变量,相比于synchronized(synchronized通常称为重量级锁),volatile更轻量级,因为它不会引起线程上下文的切换和调度。但是volatile变量的同步性较差(有时它更简单并且开销更低),而且其使用也更容易出错。
volatile的缺点:
- 频繁更改、改变、写入volatile字段 有可能导致性能问题(volatile字段未修改时,读取没有性能问题的)。
- 限制现代JVM的JIT编译器对这个字段优化(volatile字段必须遵守一定顺序,放置顺序指令重拍导致bug例如单例双检测bug)。
volatile适用场景:
- 适用于对变量的写操作不依赖于当前值,对变量的读取操作不依赖于非volatile变量。
- 适用于读多写少的场景。
- 可用作状态标志。
- JDK中ConcurrentHashMap的Entry的value和next被声明为volatile,AtomicLong中的value被声明为volatile。AtomicLong通过CAS原理(也可以理解为乐观锁)保证了原子性。
volatile的特性:
- volatile具有可见性、有序性,不具备原子性。
- volatile不具备原子性,这是volatile与synchronized、Lock最大的功能差异。
synchronized和volatile比较:
- volatile不需要加锁,比synchronized更轻量级,不会阻塞线程。
- 从内存可见性角度讲,volatile读相当于加锁,volatile写相当于解锁。
- synchronized既能保证可见性,又能保证原子性,而volatile只能保证可见性,无法保证原子性。
2.volatile的作用
(1)可见性
当一个共享变量被volatile修饰时,它会保证修改的值会立即被更新到主存,当有其他线程需要读取时,它会去内存中读取新值。普通的共享变量不能保证可见性,因为普通共享变量被修改之后,什么时候被写入主存是不确定的,当其他线程去读取时,此时内存中可能还是原来的旧值,因此无法保证可见性。
通过synchronized和Lock也能够保证可见性,synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码,并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。
非volatile修饰变量示例:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Test { static boolean bool = false;//非volatile变量 public static void main(String[] args) throws Exception{ new Thread(new Runnable() { @Override public void run() { while(!bool){ }; System.out.println("子线程运行完毕"); } }).start(); Thread.sleep(100); bool = true; System.out.println("主线程运行完毕"); } }
运行上面的示例可以看出,主线程修改了bool为true,但子线程却一直不退出循环,因为主线程的修改子线程是不可见的(子线程中获取的bool一直为false,因为子线程的变量副本一直未更新)。
volatile修饰变量示例:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Test { static volatile boolean bool = false;//非volatile变量 public static void main(String[] args) throws Exception{ new Thread(new Runnable() { @Override public void run() { while(!bool){ }; System.out.println("子线程运行完毕"); } }).start(); Thread.sleep(100); bool = true; System.out.println("主线程运行完毕"); } }
运行上面的示例可以看出,使用volatile修饰变量后,主线程修改了bool为true,子线程可见(子线程可以退出循环,因为使用volatile修饰后主线程修改了变量会导致子线程的变量副本失效,从而子线程会从主内存中拿去最新值)。
(2)有序性(禁止指令重排序)
即程序执行的顺序按照代码的先后顺序执行。当代码执行顺序不同时,多线程就会出现问题。
在Java内存模型中,允许编译器和处理器对指令进行重排序,但是重排序过程不会影响到单线程程序的执行,却会影响到多线程并发执行的正确性。
指令重排序遵循的规则:
- 重排序不会对存在依赖关系的操作进行重排。
- 重排序目的是优化性能,不管怎样重排,单线程下的程序执行结果不会变。
指令重排序示例:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Test { public void get(){ int a = 1; //1 int b = a + 1; //2 因为依赖 1指令的结果,因此1和2都不会排序 } public void get2(){ int a = 1; //1 int b = 2; //2 1和2没有依赖关系,可能发生重排 int c = a + b; //3 单线程情况下运行的结果永远是3 } }
double-check(懒汉式)单例模式示例:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
class Singleton { private volatile static Singleton singleton; /**构造函数私有,禁止外部实例化 */ private Singleton() {}; public static Singleton getInstance() { if (singleton == null) { //1.第一次检查是否为空 synchronized (Singleton.class) { //2.singleton对象上锁,初始化是由三步操作组成的复合操作,为了保障这三个步骤不可中断,使用synchronized加锁。 if (singleton == null) { //3.第二次检查是否为空,防止二次初始化 singleton = new Singleton();//4.实例化 } } } return singleton; } }
singleton = new Singleton();由三步操作组合而成,如果不使用volatile修饰,可能发生指令重排序。步骤3在步骤2之前执行,singleton引用的是还没有被初始化的内存空间,别的线程调用单例的方法就会引发未被初始化的错误。
(3)原子性
volatile只能保证单次读、写操作的原子性,多线程就会出现问题。
不能保证原子性示例:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Test { public static volatile int num = 0; public static void main(String[] args) throws Exception { //开启30个线程进行累加操作 for(int i=0;i<30;i++){ new Thread(){ public void run(){ for(int j=0;j<10000;j++) num++;//自加操作 } }.start(); } while(Thread.activeCount() > 1) //线程是否执行完成 Thread.yield(); System.out.println(num); } }
在复合操作的情景下,原子性的功能是维持不了。但是volatile对于读、写操作都是单步的情景,所以还是能保证原子性的。
要想保证原子性,只能借助于synchronized、Lock以及并发包下的atomic的原子操作类了,即对基本数据类型的自增(加1操作),自减(减1操作)、以及加法操作(加一个数),减法操作(减一个数)进行了封装,保证这些操作是原子性操作。