深入理解java中的volatile关键字

微笑听雨。

已于 2024-05-25 11:04:08 修改

阅读量6.6k

点赞数 7

分类专栏： java 进阶教程文章标签： java volatile 内存屏障乐观锁

于 2024-05-22 20:58:26 首次发布

本文链接：https://blog.csdn.net/qq_38411796/article/details/139129008

版权

java 进阶教程专栏收录该内容

60 篇文章 6 订阅

订阅专栏

深入理解 volatile 关键字

在 Java 多线程编程中，volatile 关键字是一个轻量级的同步机制，用于确保变量在多个线程之间的可见性和有序性。本文将深入解析 volatile 的原理、使用场景以及其在并发编程中的作用。
volatile 可以确保当一个线程更新共享变量时，更新操作对其他线程马上可见。当一个变量被声明为 volatile 时，线程在写入变量时不会把值缓存在寄存器或者其他地方，而是会把值刷新回主内存。
当其他线程读取该共享变量时，会从主内存重新获取最新值，而不是使用当前线程的工作内存中的值。

1. 什么是 volatile？

volatile 是 Java 提供的一种轻量级同步机制，用于修饰成员变量。被 volatile 修饰的变量在每次被线程访问时，都强制从主内存（Main Memory）中读取，而不是从线程的本地缓存（Local Cache）中读取，并在每次更新时立即刷新到主内存中，从而保证了变量的可见性和有序性。

2. volatile 的内存语义

可见性：当一个线程修改了 volatile 变量的值，新值会立即被刷新到主内存中，其他线程读取该变量时会立即从主内存中读取到最新的值。
有序性：禁止指令重排序优化。即在读写 volatile 变量时，通过内存屏障（Memory Barrier）来防止指令重排序，从而保证代码执行的顺序性。

3. volatile 的原理

volatile 的实现依赖于内存屏障（Memory Barrier），这是一种 CPU 指令，用于禁止特定的指令重排序。现代 CPU 和编译器会对指令进行优化，通过重排序提高性能，但这可能导致多线程程序中的可见性和有序性问题。内存屏障的引入确保了对 volatile 变量的读写操作在多线程环境中的正确性。

在 Java 中，JVM 在生成字节码时会在 volatile 变量的读写操作前后插入内存屏障，从而实现上述内存语义。

感兴趣的同学可以学习下java内存模型链接地址，便于加深了解

Tips：在访问 volatile 变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此 volatile 变量是一种比 sychronized 关键字更轻量级的同步机制。

4. volatile 的使用场景

4.1 状态标志：用于表示程序或线程的状态变化，如停止标志、开关等。

public class VolatileFlag {
    private volatile boolean flag = false;

    public void stop() {
        flag = true;
    }

    public void run() {
        while (!flag) {
            // 业务逻辑
        }
    }
}

4.2 单例模式: 双重检查锁定（Double-Checked Locking）实现的单例模式。

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

4.3 轻量级的读写锁: 用于实现轻量级的读写锁，如单个写线程和多个读线程的场景。

5. volatile 的局限性

虽然 volatile 可以保证变量的可见性和有序性，但它并不能保证原子性。例如，对于 volatile 修饰的计数器变量，以下操作并不是线程安全的：

public class VolatileCounter {
    private volatile int count = 0;

    public void increment() {
        count++; // 非线程安全
    }
}

对于这类需要原子性操作的场景，应该使用 AtomicInteger 或 synchronized 关键字来确保线程安全。

6. 实际应用

使用 volatile 实现简单的线程安全状态控制

public class VolatileExample {
    private volatile boolean running = true;

    public void start() {
        Thread thread = new Thread(() -> {
            while (running) {
                // 执行任务
                System.out.println("Thread is running...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("Thread stopped.");
        });
        thread.start();
    }

    public void stop() {
        running = false;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileExample example = new VolatileExample();
        example.start();
        Thread.sleep(5000); // 运行5秒后停止线程
        example.stop();
    }
}