volatile关键字原理的使用介绍和底层原理解析和使用实例
volatile关键字原理的使用介绍和底层原理解析和使用实例
volatile关键字原理的使用介绍和底层原理解析和使用实例
1. volatile 关键字的作用
volatile 关键字的主要作用是保证可见性和有序性,禁止编译器优化。
- 保证可见性:当一个变量被声明为 volatile 之后,每次读取这个变量的值都会从主内存中读取,而不是从缓存中读取,这就保证了不同线程对这个变量操作的可见性。
- 有序性:volatile 关键字保证了不同线程对一个 volatile 变量的读写操作的有序性。
- 禁止编译器优化:编译器会对代码进行各种优化来提高性能,但是这些优化也可能让同步代码失效。volatile 关键字告诉编译器不要对这段代码做优化,从而避免一些不正确的优化。
2. volatile 的底层原理
volatile 关键字底层原理依赖于内存屏障和缓存一致性协议。
- 内存屏障:内存屏障会强制让读和写操作都访问主内存,从而实现可见性。volatile 写操作后会加入写屏障,volatile 读操作前会加入读屏障。
- 缓存一致性协议:每个处理器都有自己的高速缓存,当某个处理器修改了共享变量,需要缓存一致性协议来保证其他处理器也看到修改后的值。缓存一致性协议会在读操作后和写操作前加入缓存刷新操作,保证其他处理器的缓存是最新值。
3. volatile 的使用案例
volatile 关键字常用在 DCL(Double Check Lock)单例模式中:
public class Singleton {
private volatile static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}这里使用 volatile 是为了防止指令重排序,保证 instance 初始化后其他线程可以看到。
volatile 也常用在Interruptible线程中,实现线程的中断功能:
public class InterruptibleThread extends Thread {
private volatile boolean interrupted = false;
public void interrupt() {
interrupted = true;
}
@Override
public void run() {
while (!interrupted) {
// do something
}
}
}这里 volatile 可以保证 interrupted 的可见性,使线程立即响应中断调用。
4. volatile 的原子性问题
volatile 关键字只能保证可见性和有序性,不能保证原子性。
对一个 volatile 变量的读写操作并不是原子的,而是可以分为读、改、写三个操作:
- 读: 读取 volatile 变量的值
- 改:对值进行修改
- 写:将修改后的值写入 volatile 变量
这三个操作并不是一个原子操作,在多线程环境下可能导致数据竞争问题:
public class VolatileNoAtomicDemo {
private volatile int counter = 0;
public void increase() {
counter++; // 不是原子操作
}
}这里的 counter++ 实际上分为三步:
- 读:读取 counter 的值,假设为 x
- 改:x + 1
- 写:将 x + 1 的结果写入 counter
在多线程环境下,如果两个线程同时执行 increase 方法,很有可能达不到预期结果,这就是因为 counter++ 不是一个原子操作导致的。
5. 如何解决 volatile 的原子性问题
要解决 volatile 的原子性问题,可以使用 synchronized 或 Atomic 包中的类。
使用 synchronized:
public synchronized void increase() {
counter++;
}使用 AtomicInteger:
private AtomicInteger counter = new AtomicInteger(0);
public void increase() {
counter.getAndIncrement();
}AtomicInteger 中的方法都是原子操作,可以解决 volatile 的原子性问题。
synchronized 会影响性能,AtomicInteger 的性能更好,所以一般优先选择 Atomic 包中的原子类。
6. volatile 的实现原理
volatile 的实现原理依赖于 JMM(Java Memory Model)中的几个概念:
- 主内存:所有线程都可以访问的内存,存储共享变量的值。
- 工作内存:每个线程私有的内存,用于存储线程使用的变量值。
- 内存屏障:控制读写的顺序,用于保证特定操作的完成后才允许执行后续操作。
volatile 的实现原理是:
- 当一个线程修改一个volatile变量的值时,它会在变量修改后立即刷新回主内存。
- 当一个线程读取一个volatile变量的值时,它会直接从主内存读取,而不是从工作内存读取。
- 它会在读后和写前加入内存屏障,以保证指令重排不会将内存操作重排到屏障另一侧。
这样就实现了:
- 可见性:因为每次直接读写主内存,所以每个线程都可以获得最新值。
- 有序性:内存屏障会阻止重排,读写顺序由代码决定。
- 禁止编译器优化:因为每次都要从主内存读写,编译器难以对其进行优化。
JMM的这几个概念配合volatile关键字的实现原理,就保证了多线程环境下volatile变量的可见性、有序性和禁止编译器优化。
7. 小结
- volatile关键字主要保证可见性、有序性和禁止编译器优化。
- volatile的底层原理是依赖内存屏障和缓存一致性协议实现的。
- volatile不能保证原子性,要配合synchronized或Atomic类解决。
- volatile的实现依赖JMM中的主内存、工作内存和内存屏障等概念。
8. volatile的最佳实践
根据volatile的特性,我们可以总结出一些最佳实践:
- 不要过度使用volatile volatile关键字会影响程序性能,所以不要过度使用,只在真正需要可见性和有序性保证的地方使用。
- 与synchronized一起使用 当需要保证原子性时,volatile关键字需要与synchronized关键字一起使用。synchronized可以保证代码块的原子性,volatile可以保证数据的可见性。
- 使用Atomic类代替synchronized和volatile Atomic类提供的方法都是原子操作,性能比synchronized更好,同时可以保证可见性,所以在需要保证原子性的场景可以优先选择Atomic类。
- 禁止把long和double类型变量声明为volatile 根据JMM规范,对64位数据类型的读写操作不一定是原子的,所以不要将long和double类型的变量声明为volatile。可以使用AtomicLong和AtomicDouble类代替。
- volatile不保证顺序 volatile关键字只能保证有序性,不能保证顺序。有序性是指:在一个线程内,不会由于编译器优化和处理器重新排序,使得对一个volatile变量的写操作排在读操作之前。顺序是指:两个线程访问同一个变量的顺序。所以不要依赖volatile保证线程间的顺序。
- volatile变量不能保护其它非volatile变量 在使用volatile变量控制住多线程变量的可见性时,不要认为它可以保护其它非volatile变量。每个变量都需要单独使用volatile或synchronized来保护。
9. 案例:使用volatile实现双重检查锁定
双重检查锁定(Double Check Locking)是一种使用同步控制并发访问的方式,可以实现延迟初始化。它通过两次对对象引用进行空检查来避免同步,从而提高性能。
但是在Java中,普通的双重检查锁定是不起作用的,原因是有指令重排的存在,可能导致另一个线程看到对象引用不是null,但是对象资源还没有完成初始化。
使用volatile关键字可以禁止指令重排,实现双重检查锁定。代码示例:
public class Singleton {
private volatile static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}这里把instance变量声明为volatile,可以禁止指令重排,保证在对象完成初始化后,其他线程可以正确看到instance不为null。
这种方式是实现Singleton模式的最佳方式,它只有第一次调用getInstance方法时才会同步,这样既可以实现线程安全,又有很高的性能。
10. 案例:使用volatile实现中断机制
我们可以使用一个volatile变量作为中断标志,在循环体内检查这个变量,一次循环检查后立即重新读取变量的值,保证对变量修改的可见性,从而实现中断机制。
public class VolatileInterruptionDemo extends Thread {
private volatile boolean interrupted = false;
@Override
public void run() {
while (!interrupted) {
// do something
}
System.out.println("Interrupted!");
}
public void interrupt() {
interrupted = true;
}
}这里的interrupted变量被声明为volatile,可以保证线程可以感知到中断信号,从循环体内退出。
这就是使用volatile实现的一种简单的中断机制,利用了volatile的可见性来保证线程可以正确读取到最新的中断标志。
11. 案例:使用AtomicInteger代替volatile
前面提到过,volatile不能保证原子性,要解决这个问题可以使用synchronized或Atomic类。这里我们通过一个例子来展示如何使用AtomicInteger代替volatile。
先看一个使用volatile的例子:
public class VolatileDemo {
private volatile int counter = 0;
public void increase() {
counter++;
}
public int getCounter() {
return counter;
}
} 这里的counter++不是一个原子操作,在多线程环境下会存在数据竞争问题。
现在使用AtomicInteger代替:
public class AtomicDemo {
private AtomicInteger counter = new AtomicInteger(0);
public void increase() {
counter.getAndIncrement();
}
public int getCounter() {
return counter.get();
}
}AtomicInteger的getAndIncrement()方法是一个CAS原理的原子操作,可以保证线程安全。
AtomicInteger使用CAS操作实现原子操作,CAS操作包含三个操作:
- 获取变量的当前值V
- 对V的值进行操作
- 使用CAS操作设置变量的值,这个设置值的操作需要提供变量的当前值V和新值,当变量的当前值还是V时才会设置新值,否则重新获取当前值。
CAS操作可以保证如果在多个线程同时使用一个变量时,只有一个线程可以更新变量的值,其他线程的设置值操作都会失败,这种机制可以实现原子操作。
所以,通过这个例子我们可以看出,AtomicInteger是一个很好的替代volatile的选择,它可以保证原子性也具有volatile所有特性,性能也更好,是实现原子操作的最佳选择。
12. 案例:基于volatile实现一个简单的并发容器
这里我们实现一个简单的线程安全的容器,它只包含两个方法:add()和size()。
使用volatile和synchronized实现如下:
public class VolatileContainer {
private volatile int size = 0;
private Object[] items = new Object[10];
public void add(Object item) {
synchronized (items) {
items[size] = item;
size++;
}
}
public int size() {
return size;
}
}这里使用volatile声明size变量来保证线程安全,同时使用synchronized对items数组加锁来保证添加操作的原子性。
size()方法只需要简单的读取size变量,由于它被声明为volatile,可以保证每次得到的都是最新大小值。
这是一个使用volatile和synchronized实现的简单线程安全容器,利用了volatile的可见性和synchronized的互斥锁来保证线程安全。
相比直接对整个方法加锁,这种方式的性能会更好,因为size()方法没有加锁,可以并发执行,只有在必要的add()方法进行同步,这也体现了锁的精确性原则。
13. 小结
通过这几个案例,加深了对volatile和AtomicInteger的理解,主要体会到:
- volatile可以保证可见性和有序性,但不能保证原子性,要用synchronized或Atomic类补充。
- AtomicInteger可以完全替代volatile,并且性能更好,是原子操作的最佳选择。
- 合理使用volatile和锁可以实现较高性能的线程安全程序。锁的使用要遵循精确性原则,不要过度使用。
- volatile和AtomicInteger都是JMM的重要组成部分,理解它们的实现原理有助于使用它们。
14. 案例:使用AtomicStampedReference实现ABA问题的解决
ABA问题是这样的:如果一个变量V初次读取的值是A,它的值被改成了B,后来又被改回为A,那些个依赖于V没有发生改变的线程就会产生错误的依赖。
这个问题通常发生在使用CAS操作的并发环境中,我们可以使用版本号的方式来解决这个问题,每次变量更新的时候版本号加1,那么A->B->A这个过程就会被检测出来。
AtomicStampedReference就是用过这个原理来解决ABA问题的,它包含一个值和一个版本号,我们可以这样使用:
AtomicStampedReference<Integer> atomicRef =
new AtomicStampedReference<>(100, 0);
// 获取当前值和版本号
int stamp = atomicRef.getStamp();
int value = atomicRef.getReference();
// 尝试设置新值和版本号
boolean success = atomicRef.compareAndSet(value, 101, stamp, stamp + 1);
if(success) {
// 设置成功,获取新版本号
stamp = atomicRef.getStamp();
} 这里当我们重新设置值100的时候,由于版本号已经变了,所以compareAndSet会失败,ABA问题就被解决了。
AtomicStampedReference是JUC包中用来解决ABA问题的重要工具类,实际项目中也广泛使用,它利用版本号的方式巧妙解决了这个并发编程中容易产生的问题。
另外,AtomicStampedReference的版本号使用的是int类型,所以在高并发场景下也可能存在循环的问题,这个时候可以使用时间戳方式生成版本号来避免,不过一般情况下AtomicStampedReference已经可以很好解决ABA问题。
15. 总结
OK,到这里volatile相关内容就全部介绍完了,包括:
- volatile的定义及作用:可见性、有序性和禁止优化。
- volatile的底层实现原理:JMM、缓存一致性协议和内存屏障。
- volatile的使用实例:双重检查锁定和中断机制等。
- 如何解决volatile的原子性问题:使用synchronized和Atomic类。
- AtomicStampedReference用法和ABA问题解决。
- 一些volatile的最佳实践。
- 使用volatile和锁实现的一个简单线程安全容器。
讲解的内容比较广泛,试着结合理论和实践的方式进行解释,希望可以对大家理解volatile和并发编程有所帮助。这也是我学久而久之总结的一些心得体会,与大家共同分享学习。如果 对volatile和JMM还有哪些不理解的地方,也欢迎留言讨论,我们共同进步!再次感谢阅读这篇博客,也希望您能够在学习和工作中很好地应用volatile关键字!