你张口就来volatile的了解是保证可见性,禁止指令重排,那扩展后你还能答复好吗

作者 : 开心源码 本文共4580个字,预计阅读时间需要12分钟 发布时间: 2022-05-13 共236人阅读

前言

volatile相关的知识其实自己一直都是有掌握的,能大概讲出少量知识,例如:它可以保证可见性;禁止指令重排。这两个特性张口就来,但要再往深了问,具体是如何实现这两个特性的,以及在什么场景下使用volatile,为什么不直接用synchronized这种深入和扩展相关的问题,就答复的不好了。由于volatile是面试必问知识,所以这次准备把这部分知识也给啃掉。

系统解决效率与Java内存模型

在计算机中,每条程序指令都是在CPU中执行的,而CPU执行指令的数据都是临时存储在内存中的,但是CPU的执行速度远超内存的读取速度,假如所有的CPU指令都是通过内存来读取数据的话那么将大大的降低了系统的解决效率,所以现代计算机系统都不得不加入一层或者多层读写速度尽可能接近解决器运算速度的高速缓存(Cache)来作为内存与解决器之间的缓冲。

将运算需要使用的数据复制到缓存中,让运算能快速进行,当运算结束后,在从缓存同步回内存之中,这样解决器就毋庸等待缓慢的内存读写了。

尽管说添加了高速缓存提高了CPU的解决效率,但是也带来了新的问题 :

现代计算机都是多核CPU,一开始,内存中的变量A的值是1,第一个CPU读取了数据,第二个CPU也将数据读取到了自己的高速缓存当中,当第一个CPU对变量A进行加1操作时,变量A的值变成了2,而后将将变量A的值写回内存中,这时第二个CPU也对变量A进行加1操作时,因为第二个CPU中高速缓存中的值还是1,所以加1操作后的结果为2,而后第二个CPU又将变量A的值同步回内存中,这样就导致执行了两次加1操作后,变量A的值最终是2,而不是3。 这种被多个CPU访问的变量,通常称为共享变量。 而产生的上面的问题,就是引入了高速缓存后的,主内存和缓存内容不一致的问题。 由于每个解决器有自己的高速缓存,但是它们又共享同一块主内存,所以必然会出现主内存不知该以哪个高速缓存中的变量为准的情况。

上面这个缓存不一致的问题,我们先记下来,继续来看Java内存模型,其实Java内存模型形容的上面讲的计算机系统高速缓存和内存之间的关系相似。

Java内存模型形容了,各种变量的访问规则,以及将变量存储到内存和从内存读取变量的这种底层细节。

在Java内存模型中关注的变量都是共享变量(实例变量、类变量)。 所有的共享变量都是存储在主内存中的,但是每个线程在访问变量的时候也都会在自己的工作内存(解决器高速缓存)中保留一份共享变量的副本。

Java内存模型(Java Memory Model,简称JMM)规定:

线程对变量的所有操作(读,写)都必需在工作内存中进行,不能直接操作主内存中的数据。 不同线程之间 也不能直接访问对方工作内存中的变量,线程间的变量值传递必需通过主内存进行中转传递。 在JMM中工作内存和主内存的关系如下图:

Volatile的可见性(保证立就可见)

继续我们上面的缓存一致性的问题,这个问题,在Java内存模型中,就是可见性的问题,即一个线程修改了共享变量的值,对另一个线程来说是不是立就可见的。假如不是立就可见的,那么就会出现缓存一致性的问题,假如是立就可见的,那么另一个线程在进行操作的时候,拿到的变量值就是最新的。即可以处理可见性的问题。

那么怎样处理可见性问题呢?

  • 方案一:加锁

将共享变量加锁,无论是synchronized还是Lock都可以,加锁达到的目的是在同一时间内只能有一个线程能对共享变量进行操作,就是说,共享变量从读取到工作内存到升级值后,同步回主内存的过程中,其余线程是操作不了这个变量的。这样自然就处理了可见性的问题了,但是这样的效率比较低,操作不了共享变量的线程就只能阻塞。

  • 方案二:volatile修饰修饰共享变量

当一个共享变量被volatile修饰后,会保证每个线程将变量修改后的值立即同步回主内存中,当其余线程有需要读取变量时会读取到最新的变量值。

那么volatile做了些什么操作就能处理可见性的问题呢?

被volatile修饰的变量,在被线程操作时,会有这样的机制:

就是线程对变量操作时会从主内存中读取到自己的工作内存中,当线程对变量进行了修改后,那么其余已经读取了此变量的线程中的变量副本就会失效,这样其余线程在使用变量的时候,发现已经失效,那么就会去主内存中重新获取,这样获取到的就只最新的值了。

那么volatile这个关键字是如何实现这套机制的呢?

由于一台计算机有多台CPU,同一个变量,在多个CPU中缓存的值有可能不一样,那么以谁缓存的值为准呢?

既然大家都有自己的值,那么各个CPU间就产生了一种协议,来保证按照肯定的规律为准,来确定共享变量的精确值,这样各个CPU在读写共享变量时都按照协议来操作。

这就是缓存一致性协议。

最著名的缓存一致性协议就是Intel的MESI了,说MESI时,先解释一下,缓存行:

缓存行(cache line):CPU高速缓存的中可以分配的最小存储单位,高速缓存中的变量都是存在缓存行中的。

MESI的核心思想就是,当CPU对变量进行写操作时发现,变量是共享变量,那么就会通知其余CPU中将该变量的缓存行设置为无效状态。当其余CPU在操作变量时发现此变量在的缓存行已经无效,那么就会去主内存中重新读取最新的变量。

  • 那么其余CPU是如何发现变量被修改了的呢?

由于CPU和其余部件的进行通信是通过总线来进行的,所以每个CPU通过嗅探总线上的传播数据,来检查自己缓存的值是不是过期了,当解决器发现自己换成行对应的内存地址被修改后,就会将自己工作内存中的缓存行设置成无效状态,当CPU对此变量进行修改时会重新从系统主内存中读取变量。

Volatile的有序性(禁止指令重排)

一般来说,我们写程序的时候,都是要把先代码从上往下写,默认的认为程序是自顶向下顺序执行的,但是CPU为了提高效率,在保证最终结果精确的情况下,是会对指令进行重新排序的。就是说写在前的代码不肯定先执行,在后面的也不肯定晚执行。

举个例子:

int a = 5; // 代码1int b = 8; // 代码2a = a + 4;  // 代码3int c = a + b;  // 代码4

上面四行代码的执行顺序有可能是

JMM在是允许指令重排序的,在保证最后结果正确的情况下,解决器可以尽情的发挥,提高执行效率。

当多个线程执行代码的时候重排序的情况就更为突出了,各个CPU为了提高自己的效率,有可能会产生竞争情况,这样就有可能导致最终执行的正确性。

所以为了保证在多个线程下最终执行的正确性,将变量用volatile进行修饰,这样就会达到禁止指令重排序的效果(其实也可以通过加锁,还有少量其余已知规则来实现禁止指令重排序,但是我们这里只探讨volatile的实现方式)。

那么volatile是如何实现指令重排序的呢?

答案是:内存屏障

内存屏障是一组CPU指令,用于实现对内存操作的顺序限制。 Java编译器,会在生成指令系列时,在适当的位置会插入内存屏障来禁止解决器对指令的重新排序。

volatile会在变量写操作的前后加入两个内存屏障,来保证前面的写指令和后面的读指令是有序的。

volatile在变量的读操作后面插入两个指令,禁止后面的读指令和写指令重排序。

有序性,不仅只有volatile能保证,其余的实现方式也能保证,但是假如每一种实现方式都要理解那对于开发人员来说就比较困难了。

所以从JDK5就出现了happen-before准则,也叫先行发生准则。 先行发生准则总结起来就是:假如一个操作A的产生的影响能被另一个操作B观察到,那么可以说,这个操作A先行发生与操作B。

这里所说的影响包括内存中的变量的修改,调用了方法,发送量消息等。

volatile中的先行发生准则是,对一个volatile变量的写操作,先行发生于后面任何地方对这个变量的读操作。

Volatile无法保证原子性

原子性,是指一个操作过程要么都成功,要么都失败,是一个独立的完整的。

就像上面说的,假如多个线程对一个变量进行累加,那么一定得不到想要的结果,由于累加就不是一个原子操作。

要保证累加最终结果正确,要么对累加变量加锁,要么就用AotomicInteger这样的变量。

/** * 双重检查加锁式单例 */public class DoubleCheckLockSingleton implements Serializable{    /**     * 静态变量,用来存放实例。     */    private volatile static DoubleCheckLockSingleton doubleCheckLockSingleton = null;    /**     * 私有化构造方法,禁止外部创立实例。     */    private DoubleCheckLockSingleton(){}    /**     * 双重检查加锁的方式保证线程安全又能取得到唯一实例     * @return     */    public static DoubleCheckLockSingleton getInstance(){        //第一次检查实例能否已经存在,不存在则进入代码块        if(null == doubleCheckLockSingleton){            synchronized (DoubleCheckLockSingleton.class){                //第二次检查                if(null==doubleCheckLockSingleton){                    doubleCheckLockSingleton = new DoubleCheckLockSingleton();                }            }        }        return doubleCheckLockSingleton;    }}

为什么要进行双重检查呢? 当第一个线程走到第一次检查时发现对象为空,而后进入锁,第二次就检查时也为空,那么就去创立对象,但是这个时候又来了一个线程来到了第一次检查,发现为空,但是这个时候由于锁被占用,所以就只能阻塞等待,而后第一个线程创立对象成功了,因为对象是被volatile修饰的能够立即反馈到其余线程上,所以在第一个线程释放锁之后,第二个线程进入了锁,而后进行第二次检查时,发现对象已经被创立了,那么就不在创立对象了。从而保证的单例。

还有就是假如创立对象,步骤:

  1. 分配内存空间。

  2. 调用构造器,实例化。

  3. 返回内存地址给引用。

假如这三个指令顺序被重排了,那么当多线程来获取对象的时候就会造成对象尽管实例化了,但是没有分配内存空间,会有空指针的风险。 所以加上了volatile的对象,也保证了在第二次检查时不会被已经在创立过程中的对象有被检测为空的风险。

总结一下

volatile其实可以看作是轻量级的synchronized,尽管说volatile不能保证原子性,但是假如在多线程下的操作本身就是原子性操作(例如赋值操作),那么使用volatile会因为synchronized。

volatile可以适用于,某个标识flag,一旦被修改了就需要被其余线程立就可见的情况。也可以修饰作为触发器的变量,一旦变量被任何一个线程修改了,就去触发执行某个操作。

volatile的变量写操作happen-before,后面任何对此volatile变量的读操作。

写在最后

大家看完有什么不懂的可以在下方留言探讨.
谢谢你的观看。
觉得文章对你有帮助的话记得关注我点个赞支持一下!

作者:熬夜不加班
链接:https://juejin.cn/post/6917517239096705037

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 你张口就来volatile的了解是保证可见性,禁止指令重排,那扩展后你还能答复好吗

发表回复