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;}@Overridepublic 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++ 实际上分为三步:

1. 读:读取 counter 的值,假设为 x
2. 改:x + 1
3. 写:将 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 的实现原理是:

1. 当一个线程修改一个volatile变量的值时,它会在变量修改后立即刷新回主内存。
2. 当一个线程读取一个volatile变量的值时,它会直接从主内存读取,而不是从工作内存读取。
3. 它会在读后和写前加入内存屏障,以保证指令重排不会将内存操作重排到屏障另一侧。

这样就实现了:

• 可见性:因为每次直接读写主内存,所以每个线程都可以获得最新值。
• 有序性:内存屏障会阻止重排,读写顺序由代码决定。
• 禁止编译器优化:因为每次都要从主内存读写,编译器难以对其进行优化。

JMM的这几个概念配合volatile关键字的实现原理,就保证了多线程环境下volatile变量的可见性、有序性和禁止编译器优化。

7. 小结

• volatile关键字主要保证可见性、有序性和禁止编译器优化。
• volatile的底层原理是依赖内存屏障和缓存一致性协议实现的。
• volatile不能保证原子性,要配合synchronized或Atomic类解决。
• volatile的实现依赖JMM中的主内存、工作内存和内存屏障等概念。

8. volatile的最佳实践

根据volatile的特性,我们可以总结出一些最佳实践:

1. 不要过度使用volatile

   volatile关键字会影响程序性能,所以不要过度使用,只在真正需要可见性和有序性保证的地方使用。

2. 与synchronized一起使用

   当需要保证原子性时,volatile关键字需要与synchronized关键字一起使用。synchronized可以保证代码块的原子性,volatile可以保证数据的可见性。

3. 使用Atomic类代替synchronized和volatile

   Atomic类提供的方法都是原子操作,性能比synchronized更好,同时可以保证可见性,所以在需要保证原子性的场景可以优先选择Atomic类。

4. 禁止把long和double类型变量声明为volatile

   根据JMM规范,对64位数据类型的读写操作不一定是原子的,所以不要将long和double类型的变量声明为volatile。可以使用AtomicLong和AtomicDouble类代替。

5. volatile不保证顺序

   volatile关键字只能保证有序性,不能保证顺序。有序性是指:在一个线程内,不会由于编译器优化和处理器重新排序,使得对一个volatile变量的写操作排在读操作之前。顺序是指:两个线程访问同一个变量的顺序。所以不要依赖volatile保证线程间的顺序。

6. 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;@Overridepublic 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操作包含三个操作:

1. 获取变量的当前值V
2. 对V的值进行操作
3. 使用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的理解,主要体会到:

1. volatile可以保证可见性和有序性,但不能保证原子性,要用synchronized或Atomic类补充。
2. AtomicInteger可以完全替代volatile,并且性能更好,是原子操作的最佳选择。
3. 合理使用volatile和锁可以实现较高性能的线程安全程序。锁的使用要遵循精确性原则,不要过度使用。
4. 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相关内容就全部介绍完了,包括:

1. volatile的定义及作用:可见性、有序性和禁止优化。
2. volatile的底层实现原理:JMM、缓存一致性协议和内存屏障。
3. volatile的使用实例:双重检查锁定和中断机制等。
4. 如何解决volatile的原子性问题:使用synchronized和Atomic类。
5. AtomicStampedReference用法和ABA问题解决。
6. 一些volatile的最佳实践。
7. 使用volatile和锁实现的一个简单线程安全容器。

讲解的内容比较广泛,试着结合理论和实践的方式进行解释,希望可以对大家理解volatile和并发编程有所帮助。这也是我学久而久之总结的一些心得体会,与大家共同分享学习。如果 对volatile和JMM还有哪些不理解的地方,也欢迎留言讨论,我们共同进步!再次感谢阅读这篇博客,也希望您能够在学习和工作中很好地应用volatile关键字!