稀有猿诉

理解Java关键字volatile

2023-05-29  本文已影响0人  alexhilton

原文链接 理解Java关键字volatile

在Java中，关键字volatile是除同步锁以外，另一个同步机制，它使用起来比锁要简单方便，但是却很容易被忽略，或者被误用。这篇文章就来详细讲解一下volatile它的作用，它的原理以及如何正确的使用它。

[图片上传失败...(image-6f8232-1685442090002)]

volatile的定义

这个引用JSR中的定义：

The Java programming language allows threads to access shared variables (§17.1). As a rule, to ensure that shared variables are consistently and reliably updated, a thread should ensure that it has exclusive use of such variables by obtaining a lock that, conventionally, enforces mutual exclusion for those shared variables.

The Java programming language provides a second mechanism, volatile fields, that is more convenient than locking for some purposes.

A field may be declared volatile, in which case the Java Memory Model ensures that all threads see a consistent value for the variable (§17.4).

简单的翻译一下：

Java编程语言中允许线程访问共享变量。为了确保共享变量能被一致地和可靠的更新，线程必须确保它是排他性的使用此共享变量，通常都是获得对这些共享变量强制排他性的同步锁。

Java编程语言提供了另一种机制，volatile域变量，对于某些场景的使用这要更加的方便。

可以把变量声明为volatile，以让Java内存模型来保证所有线程都能看到这个变量的同一个值。

volatile的作用

private volatile boolean flag;
    
public void setFlag(boolean flag) {
    this.flag = flag;
}
    
public void getFlag() {
    return flag;
}

假设线程A来调用setFlag(true)，线程B同时来调用getFlag，对于一般的变量，是无法保证B能读到A设置的值的，因为它们执行的顺序是未知的。但是像上面，加上volatile修饰以后，虚拟机会保证，线程A的写操作在线程B的读操作之前完成，换句话，B能读到最新的值。当然了，用锁机制也能达到同样的效果，比如在方法前面都加上synchronized关键字，但是性能会远不如使用volatile。

volatile的典型使用场景

多线程情况下的标志位

基于它的作用，不难找到使用它的理想场景：

比如，有一个检查新版本的按扭，点击时会发起去检查新版本，因为检查新版本涉及网络请求，可能会比较耗时，所以需要放在单独的线程中去做。为了避免多次同时触发检查请求，做一个限制：上一个请求没有完成时，再次点击无效。这时就可以用volatile来做个标志位，伪代码如下：

private volatile boolean checkUpdateFinished = true;

public void onCheckUpdate(View view) {
    if (!checkUpdateFinished) {
        return;
    }
    checkUpdate();
}

private void checkUpdate() {
    checkUpdateFinished = false;
    new Thread(new Runnable() {
        @Override
        public void run() {
            doCheckUpdate();
            checkUpdateFinished = true;
        }
    }).start();
}

CAS无锁同步的变量声明

CAS（Compare And Swap）是一种无锁同步的算法，它涉及变量的3个值，当前值，旧的期望值以及新的期望值，它的原理是当且仅当当前值与旧的期望值一致时，才把新值赋给变量，否则什么都不做：

private volatile int a;

do {
   old = 3;
   expected = 5;
} while (compareAndSwap(a, 3, 5);

boolean compareAndSwap(int a, int old, int expected) {
    if (a == old) {
        a = expected;
        return true;
    }
    return false;
}

当然，具体的compare and swap不是这么实现的，实际是要直接使用处理的指令CMPXCHG(Compare and Exchange)来做具体的CAS。
为了保证可见性，CAS中的变量必须都用volatile来修饰。

volatile的内存原理

知道了volatile有什么用，怎么用以后，可以了解的更深一点，以加深理解。但要搞懂，就必须先要搞懂它的背景以及背景的背景：

并发的基本概念

  int a = 10;
  int b = a + 1;

这段代码的有序性的意思是：当执行到第二条语句，只要a的值是10就可以了，至于a = 10它究竟是否是在下面语句前执行，并不关心。但是，除了a = 10语句外，没有其他的方式能让a变成10，所以，肯定是执行了语句了才能把a变成10。说起来比较绕，这个例子也过于简单。但是可以这么简单的理解为：单线程情况下，程序是按书写的顺序来执行的，更准确的说法是程序员预期的顺序来执行的。但多线程会打破这种有序性。

注意：这里我们不考虑ABA问题。

对内存模型的理解

什么是内存模型呢？就是程序运行起来时，内存里面的样子。程序包括变量，对象，数据，指令等，程序动起来后又包括变量如何赋值，数据如何读取，指令按什么顺序执行等。其实，程序运行时，内存是什么样子，通常取决于操作系统，也就是说是由操作系统决定的。Java是跨平台的语言，其靠着“Compile once, run anywhere"的大旗，拮杆而起，打下一片天下，如今稳坐头把交椅。那么，想要跨平台，它就要屏蔽各个操作系统平台和硬件平台的差异，因此它有虚拟机，虚拟机实质是一对操作系统的一个抽象，把差异进行屏蔽，从而对语言本身来说，所有操作系统就都是一样的了。内存模型，也就是虚拟机对运行时的一些约定，或者叫做强制规定，比如变量的操作，数据的读取，指令执行顺序等。都做了哪些规定呢？我们分别来说：

[图片上传失败...(image-c4db61-1685442090002)]

因为Java天生支持多线程，所以，虚拟机也必须要有线程模型，否则就无法屏蔽操作系统的差异。虚拟机规定，所有的变量都存储在主存中，也就是通常所指的内存，每个线程可以有自己的独立的工作内存，可以理解为每个CPU核心的缓存，线程对变量的操作都只能在自己的工作内存中，不能直接对主存操作，也不能访问其他线程的工作内存。

int a = 1;
int b = 2;
int c = 3;

这三个指令，哪个先执行，是不会影响程序结果的，这时指令可能重排；而再如：

int a = 1;
int b = a + 1;
int c = a + b;

这种情况下，是无法重排，不可能把第3句放到前面，那样会得不到正确的结果。

而happens-before是指在多线程情况下，虚拟机来保证某些操作的先后性，或者说前面的操作结果，对后面是可见的。比如上面的第二个例子，在多线程情况下，c = a + b是有可能在a, b赋值前执行的，这也恰 恰是我们需要小心解决的由多线程机制带来的问题。

虚拟机的默认支持的happens-before(先行发生)原则：

很多规则显而易见的，或者想一下还是很容易想通的，重点解析一下第2, 3, 4条：

int a;
int b;
volatile boolean flag;
            
void write() {
    a = 3;
    b = 4;
    flag = true;
}
            
void read() {
    print(a);
    print(b);
    print(flag);
}

如果线程A调用write()，线程B调用read()，那么B能读到a, b和flag的最新值（A所写的值）。

由此，可以引申出一个volatile的高级应用，可以当作同步锁：

private Object object = null;
private volatile hasNewObject = false;
            
public void put(Object newObject) {
    while (hasNewObject) {
         //wait - do not overwrite existing new object
    }
    object = newObject;
    hasNewObject = true; //volatile write
}
            
public Object take() {
    while (!hasNewObject) { //volatile read
        //wait - don't take old object (or null)
    }
    Object obj = object;
    hasNewObject = false; //volatile write
    return obj;
}

因为写hasNewObject时会把object也刷新了，所以取对象的线程，可以在只要hasNewObject为true时就可以读到正确的值。

这个就像某些运行符的传递性一样，具体传递性，从而使整个happens-before规则产生实际作用。

volatile的实现机制

计算机科学里面，为了解决复杂性，都会分层。正如一个名人所说："计算机的任何问题都可以通过增加一个虚拟层来解决"("All problems in computer science can be solved by another level of indirection")。volatile虚拟机层引入的，解决语言层面的问题，那么它的实现，必然是靠下一层的支持，也就是需要汇编或者说处理器指令的支持来实现，volatile是靠内存屏障和MESI（缓存一致性协议）来达成的它的作用的。

内存屏障(Memory Barriers)是处理器提供的一组内存操作指令，它的作用是限制内存操作的顺序，也就是说内存屏障像一个栅栏一样，它前面的指令要在它后面的指令之前完成；还能强制把缓存写入到主存；再有的就是触发缓存一致性，就是当有写变量时，会把其他CPU核心的缓存变为无效。

总结

volatile是一个比较复杂的修饰符，想要使用它，就要完全理解它的作用，它能用来做什么，以及不能干什么。如果，不是很确定，要么弄懂，要么就不要使用。事实上，大多数情况下，标志变量，还是非常适合volatile的。

java.util.concurrent.*里面的高级线程安全数据结构像ConcurrentHashMap以及java.util.concurrent.atomic.*等的实现都用到了volatile。可以多看看这些类的实现，以加深对volatile的理解和运用。

参考资料

原创不易，打赏，点赞，在看，收藏，分享 总要有一个吧

上一篇 下一篇

猜你喜欢

热点阅读