volatile 关键字

Flying_Fish_Xuan

于 2024-10-14 08:46:27 发布

阅读量1k

点赞数 7

文章标签： java 开发语言

本文链接：https://blog.csdn.net/Flying_Fish_roe/article/details/142908610

版权

在Java并发编程中，volatile关键字是用于处理共享变量的一个重要工具。它确保了变量的可见性和一定程度的有序性，但不提供互斥行为。理解volatile的作用及其适用场景，对于编写正确和高效的多线程程序至关重要。

1. `volatile`的定义与作用

volatile是Java中的一个关键字，用于修饰变量。它的主要作用有两个：

保证变量的可见性：当一个线程修改了volatile变量的值，新值对其他线程立即可见。
禁止指令重排序：在某些情况下，volatile变量可以防止编译器和CPU对指令进行重排序，从而确保一定的有序性。

1.1 变量的可见性

在多线程环境下，每个线程可能有自己的CPU缓存，线程在读取和写入共享变量时，可能只在自己的缓存中操作，而不是直接操作主内存中的值。这就可能导致一个线程对变量的修改对其他线程不可见。

volatile关键字通过禁止线程缓存来解决这个问题。当一个变量被声明为volatile时，线程对该变量的所有读写操作都将直接操作主内存，而不是缓存。因此，当一个线程修改了volatile变量，其他线程可以立即看到这个变化。

例如：

public class VolatileExample {
    private volatile boolean flag = false;

    public void updateFlag() {
        flag = true;
    }

    public void checkFlag() {
        if (flag) {
            System.out.println("Flag is true");
        }
    }
}

在这个例子中，如果flag没有被声明为volatile，updateFlag()方法修改flag的值后，checkFlag()方法可能在另一个线程中读取的是旧值（false）。但是，volatile确保了updateFlag()对flag的修改对其他线程立即可见，因此checkFlag()方法会读取到最新的值（true）。

1.2 禁止指令重排序

指令重排序是一种编译器和处理器为了优化性能而进行的操作。它们可能会改变程序中语句的执行顺序，只要不影响单线程程序的语义。在多线程环境下，这种重排序可能导致意外的结果。

volatile通过加入内存屏障（Memory Barrier）来防止指令重排序。对volatile变量的写操作不能与之前的指令重排序，对volatile变量的读操作不能与之后的指令重排序。

例如：

public class DoubleCheckedLocking {
    private volatile static DoubleCheckedLocking instance;

    public static DoubleCheckedLocking getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (DoubleCheckedLocking.class) {
                if (instance == null) { // 第二次检查
                    instance = new DoubleCheckedLocking();
                }
            }
        }
        return instance;
    }
}

在这个例子中，instance被声明为volatile，这样即使编译器或处理器尝试重排序，也不能将new DoubleCheckedLocking()的操作分解为多个步骤（分配内存、初始化对象、将引用指向对象），从而防止了未完全初始化的对象被其他线程访问。

2. `volatile`的底层实现

volatile关键字的底层实现依赖于Java内存模型和CPU的内存屏障指令。

2.1 内存屏障（Memory Barrier）

内存屏障是一种硬件指令，用于防止指令重排序，并确保内存操作的可见性。Java编译器在生成字节码时，遇到volatile变量时，会插入内存屏障指令：

读屏障（Load Barrier）：在读取volatile变量之前插入，确保此后的读操作不被重排序到volatile读操作之前。
写屏障（Store Barrier）：在写入volatile变量之后插入，确保之前的写操作不被重排序到volatile写操作之后。

这些屏障确保了对volatile变量的读写操作的顺序性和可见性。

2.2 CPU缓存一致性协议

现代CPU使用缓存来提高性能，但这也导致了在多核系统中，缓存与主内存之间的同步问题。为了确保多个CPU核心之间的数据一致性，CPU实现了缓存一致性协议，如MESI（Modified, Exclusive, Shared, Invalid）协议。

当一个线程修改了一个volatile变量，CPU通过一致性协议确保该修改被刷新到主内存，并通知其他CPU核心使其缓存中的值失效。因此，其他线程在访问这个volatile变量时，会重新从主内存中读取最新值。

3. `volatile`的适用场景

volatile适用于某些特定的多线程场景，特别是在不需要使用锁的情况下保证变量的可见性和有序性。

3.1 状态标志

volatile通常用于实现简单的状态标志或控制变量，用于通知线程某个事件的发生。例如，volatile可以用于实现停止线程的标志：

public class StopThread {
    private volatile boolean stop = false;

    public void run() {
        while (!stop) {
            // 线程执行任务
        }
    }

    public void stopThread() {
        stop = true;
    }
}

在这个例子中，stop变量被声明为volatile，这样stopThread()方法对stop的修改可以立即被run()方法中的线程看到，从而正确停止线程。

3.2 双重检查锁（Double-Checked Locking）

在前面提到的双重检查锁实现单例模式中，volatile被用于确保对象初始化的正确性和可见性。

3.3 轻量级读写锁

对于一些读多写少的场景，volatile可以代替锁来实现轻量级的同步机制。例如，volatile可以用来实现一个简单的缓存，确保多线程环境下读写操作的可见性：

public class SimpleCache {
    private volatile Map<String, Object> cache = new HashMap<>();

    public Object get(String key) {
        return cache.get(key);
    }

    public void put(String key, Object value) {
        Map<String, Object> newCache = new HashMap<>(cache);
        newCache.put(key, value);
        cache = newCache;
    }
}

在这个例子中，cache变量被声明为volatile，这样读写操作可以立即可见，且由于写操作创建了一个新的副本，可以避免锁的使用。

4. `volatile`与`sychronized`的区别

volatile和synchronized都用于解决多线程问题，但它们在功能和使用场景上有所不同。

4.1 功能对比

可见性：volatile保证变量的可见性，即当一个线程修改volatile变量时，其他线程立即可以看到这个变化。synchronized也能保证可见性，因为在释放锁之前，线程会把变量的值刷新到主内存中，获取锁的线程会从主内存中重新读取变量的值。
原子性：volatile不保证操作的原子性。例如，volatile不能用于计数器递增（i++）操作，因为该操作不是原子操作。synchronized不仅保证可见性，还能保证原子性，确保同步代码块或方法在执行时不会被其他线程中断。
锁机制：volatile不涉及锁，因此不会引起线程阻塞，适合在轻量级场景下使用。synchronized使用了内置锁机制，可能会引发线程的上下文切换，适合复杂的同步需求。

4.2 使用场景对比

volatile适用场景：适合用于状态标志、单例模式中的双重检查锁定、轻量级读写操作等场景。适用于变量的读写操作比较简单，不需要进行复杂的逻辑控制。
synchronized适用场景：适合用于需要控制方法或代码块执行顺序的场景，确保在多线程环境下共享资源的访问是安全的。尤其是在涉及复杂的操作，如多个变量的组合操作时，synchronized是必要的。