Java并发编程：Volatile不能保证数据同步(Java并发编程深度解析：Volatile为何无法确保数据同步？)

原创

ithorizon 6个月前 (10-19) 阅读数 26 #后端开发

Java并发编程：Volatile为何无法确保数据同步？

一、Volatile简介

在Java并发编程中，Volatile关键字是一个轻量级的同步机制，它可以保证变量的可见性，即一个线程对这个变量的修改，对其他线程来说是立即可见的。Volatile的底层实现原理是借助于CPU的内存屏障（Memory Barrier）和缓存一致性协议（Cache Coherence）来实现的。

二、Volatile的内存语义

Volatile的内存语义可以总结为以下两点：

保证不同线程对共享变量访问的可见性；

禁止指令重排序。

三、Volatile无法保证数据同步的原因

尽管Volatile关键字可以保证变量的可见性，但它并不能保证数据同步，原因如下：

1. 无法保证原子性

原子性指的是一个操作在其他线程看来是不可分割的，即线程在执行这些操作时不会被中断。Volatile关键字只能保证操作的可见性，但不能保证操作的原子性。以下是一个示例代码：


public class VolatileExample {
    private volatile boolean flag = false;
    public void writer() {
        flag = true; // 语句1
        // ... 也许会有其他操作
    }
    public void reader() {
        if (flag) { // 语句2
            // ... 也许会有其他操作
        }
    }
}

在上述代码中，假设writer()方法在线程A中执行，reader()方法在线程B中执行。由于Volatile的内存语义，线程B可以立即看到线程A对flag变量的修改。但是，如果语句1和语句2之间存在其他操作，那么这些操作也许会出现指令重排序，引起线程B看到的是一个不一致的状态。

2. 无法保证有序性

有序性指的是程序执行的顺序按照代码的先后顺序执行。由于Volatile禁止指令重排序，故而它可以保证单个操作的有序性。但是，对于复合操作，Volatile并不能保证其有序性。以下是一个示例代码：


public class VolatileExample {
    private int a = 0;
    private volatile boolean flag = false;
    public void writer() {
        a = 1; // 语句1
        flag = true; // 语句2
    }
    public void reader() {
        if (flag) {
            int i = a * a; // 语句3
            // ... 也许会有其他操作
        }
    }
}

在上述代码中，如果线程A执行writer()方法，线程B执行reader()方法。由于Volatile的内存语义，线程B可以立即看到线程A对flag变量的修改。但是，如果语句1和语句2之间出现指令重排序，那么线程B看到的于是也许是a=0，flag=true，这与线程A的执行顺序不符。为了解决这个问题，可以在writer()方法中增长一个额外的volatile变量，用于确保语句1和语句2之间的顺序。例如，可以增长一个volatile修饰的变量作为锁，保证writer()方法中的语句1和语句2之间不会出现指令重排序。以下是修改后的代码：


public class VolatileExample {
    private int a = 0;
    private volatile boolean flag = false;
    private volatile int lock = 0;
    public void writer() {
        a = 1; // 语句1
        lock = 1; // 保证语句1和语句2之间的顺序
        flag = true; // 语句2
    }
    public void reader() {
        if (flag) {
            int i = a * a; // 语句3
            // ... 也许会有其他操作
        }
    }
}

这样，线程B在执行reader()方法时，可以通过检查lock变量的值来确保语句1和语句2之间的顺序。如果lock的值不是1，那么线程B将等待，直到writer()方法完成对lock变量的修改。

3. 无法保证引用类型的完整性

当Volatile修饰引用类型时，它只能保证引用本身的可见性，而不能保证引用对象内部字段的可见性。以下是一个示例代码：


public class VolatileExample {
    private volatile Person person = new Person();
    public void writer() {
        person.name = "Alice"; // 语句1
        person.age = 30; // 语句2
    }
    public void reader() {
        if (person != null) {
            System.out.println(person.name + " is " + person.age + " years old.");
        }
    }
}
class Person {
    public String name;
    public int age;
}

在上述代码中，尽管person变量被声明为Volatile，但它的name和age字段并不是Volatile。故而，即使writer()方法在线程A中执行，reader()方法在线程B中执行，线程B也无法立即看到线程A对name和age字段的修改。为了解决这个问题，可以将name和age字段也声明为Volatile，或者使用锁机制来保证操作的原子性和有序性。