深入剖析 Java `volatile` 关键字：原理、应用与实践案例

咦咦咦，各位小可爱，我是你们的好伙伴——bug菌，今天又来给大家普及Java SE相关知识点了，别躲起来啊，听我讲干货还不快点赞，赞多了我就有动力讲得更嗨啦！所以呀，养成先点赞后阅读的好习惯，别被干货淹没了哦~

🏆本文收录于「滚雪球学Java」专栏中，这个专栏专为有志于提升Java技能的你打造，覆盖Java编程的方方面面，助你从零基础到掌握Java开发的精髓。赶紧关注，收藏，学习吧！

环境说明：Windows 10 + IntelliJ IDEA 2021.3.2 + Jdk 1.8

前言

在并发编程中，正确处理共享变量对于确保程序的正确性和高效性至关重要。Java 提供了多种手段来管理共享变量的可见性和一致性，其中 volatile 关键字是一个简单却强大的工具。虽然相比锁机制 (synchronized 或 ReentrantLock)，volatile 更加轻量，但其作用在某些场景下却十分关键。

本文将全面剖析 volatile 关键字的原理、使用场景及其在Java内存模型中的作用。通过详尽的代码示例，帮助读者更好地理解如何在并发编程中正确使用 volatile，并深入探讨其应用场景与局限性，最终提升对Java并发编程的掌握程度。

一、什么是 volatile 关键字？

volatile 是Java中的一个修饰符，用于保证被它修饰的变量在多个线程之间的可见性。当一个变量被声明为 volatile 时，表示该变量的值将不被线程缓存，任何对该变量的读写都直接操作主存。这意味着，当一个线程修改了这个变量的值，其他线程立即可以读取到最新的值。

1.1 为什么需要 volatile？

在多线程编程中，线程通常会将共享变量的副本保存在本地缓存中（如CPU缓存）以提高访问速度，这意味着一个线程可能无法及时看到其他线程对共享变量的修改。此时，使用 volatile 可以确保线程间的可见性，避免“不可见”问题。

举个简单的例子：

public class VolatileExample {
    private static volatile boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            while (!flag) {
                // 等待flag变为true
            }
            System.out.println("Flag is true, thread1 ends.");
        });

        Thread thread2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
                flag = true; // 修改flag
                System.out.println("Flag set to true by thread2.");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
    }
}

在上述例子中，flag 变量被多个线程共享，且使用 volatile 来保证它的可见性。当 thread2 修改 flag 的值时，thread1 能够立即感知到变化，从而跳出循环。

1.2 volatile 的作用机制

volatile 关键字通过以下两点来确保线程间的共享变量可见性：

1. 可见性保证：volatile 修饰的变量被写入时，强制线程将该变量的修改刷新到主内存中，并且读取 volatile 变量时，强制从主内存中读取最新值，而不是使用缓存。
2. 防止指令重排序：JVM 和 CPU 都会对代码执行顺序进行优化，而这种优化可能会导致指令的执行顺序与代码顺序不一致。volatile 禁止了某些特定的指令重排序，从而保证代码的执行顺序在多线程环境下是有序的。

1.3 volatile 不保证原子性

需要注意的是，volatile 只保证了可见性，但并不保证操作的原子性。举例来说，假设我们对 volatile 修饰的变量进行 i++ 操作，i++ 实际上分为三步：读取变量、递增、写回。这三步操作并不是原子性的，因此在多线程场景中，可能会出现“竞态条件”（race condition）的问题。

以下是一个例子，展示了 volatile 不能解决并发问题中的原子性问题：

public class VolatileNonAtomic {
    private static volatile int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count++; // 递增操作
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count++; // 递增操作
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final count: " + count);
    }
}

在这个例子中，count 应该在两条线程的作用下最终结果为2000，但实际运行结果通常会小于2000，因为 count++ 并不是一个原子操作，多个线程可能在相同时间内读取相同的 count 值，导致递增结果被覆盖。

二、volatile 的使用场景

尽管 volatile 并不保证原子性，但它仍然是并发编程中的重要工具，尤其是在某些特定的使用场景下能够很好地发挥作用。

2.1 状态标记

volatile 非常适合用作状态标记。像示例中展示的那样，一个线程用 volatile 变量来控制另一个线程的运行状态。例如，线程间需要基于某个共享标志来决定是否继续执行时，volatile 是一个轻量的选择。

public class VolatileFlag {
    private static volatile boolean shutdown = false;

    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            while (!shutdown) {
                // 执行任务
            }
            System.out.println("Worker thread shutdown.");
        });

        worker.start();
        Thread.sleep(1000);
        shutdown = true; // 通过volatile变量改变线程状态
        worker.join();
    }
}

2.2 双重检查锁定（DCL）单例模式

在某些场景中，volatile 可以与锁结合使用，确保在多线程环境中，变量被正确初始化。例如，双重检查锁定（Double-Checked Locking，DCL）是单例模式的一种优化方法，它通过 volatile 保证单例对象在多线程环境中的安全性。

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;
    }
}

volatile 确保了在多个线程中创建单例对象的过程中，所有线程都能看到已经被初始化完成的正确对象。

2.3 轻量级的读写锁替代

volatile 可以用于某些场景中取代读写锁，特别是在数据读取远多于写入的情况下。通过 volatile 来保证可见性，而非强制加锁，可以提高程序的并发性能。

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

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

    public void put(String key, String value) {
        cache.put(key, value); // 写操作
    }
}

在此示例中，虽然写操作不是原子性的，但如果写操作不频繁，volatile 仍然能够提供足够的性能保证。

三、volatile 的局限性

虽然 volatile 是一个有用的工具，但它在并发编程中也有一定的局限性。

3.1 不保证原子性

正如前文所述，volatile 不能解决原子性问题。当需要保证操作的原子性时，仍然需要使用锁（如 synchronized 或 ReentrantLock）来确保线程安全。

3.2 不适合复杂的状态依赖

volatile 仅适合单个变量的读写操作。在涉及到多个变量的操作时，volatile 不能保证它们之间的状态依赖一致性。例如，如果多个共享变量相互依赖，那么仅使用 volatile 是不够的。

3.3 高频率写操作性能问题

尽管 volatile 提供了一种轻量级的锁替代，但它依赖于强制的内存可见性同步。在频繁写操作的情况下，可能会导致性能瓶颈，因为每次写操作都会导致缓存无效化，影响系统的并发性能。

四、总结

volatile 是 Java 并发编程中的重要组成部分，它通过保障可见性和防止指令重排序，为开发者提供了一个轻量级的同步机制。虽然 volatile 不保证原子性，也不能处理复杂的同步需求，但在一些特定场景下，如状态标志、轻量读写操作、双

重检查锁定等，它能够提供有效的性能优化。

在实际应用中，开发者需要理解 volatile 的工作原理及其局限性，合理选择同步机制，以确保并发程序的正确性与高效性。希望通过本文的深入剖析，读者能够在编写并发代码时更加得心应手，避免常见的并发陷阱。

☀️建议/推荐你

无论你是计算机专业的学生，还是对编程有兴趣的小伙伴，都建议直接毫无顾忌的学习此专栏「滚雪球学Java」，bug菌郑重承诺，凡是学习此专栏的同学，均能获取到所需的知识和技能，全网最快速入门Java编程，就像滚雪球一样，越滚越大，指数级提升。

码字不易，如果这篇文章对你有所帮助，帮忙给bug菌来个一键三连(关注、点赞、收藏) ，您的支持就是我坚持写作分享知识点传播技术的最大动力。
  同时也推荐大家关注我的硬核公众号:「猿圈奇妙屋」 ；以第一手学习bug菌的首发干货，不仅能学习更多技术硬货，还可白嫖最新BAT大厂面试真题、4000G Pdf技术书籍、万份简历/PPT模板、技术文章Markdown文档等海量资料，你想要的我都有！

📣关于我

我是bug菌，CSDN | 掘金 | infoQ | 51CTO 等社区博客专家，历届博客之星Top30，掘金年度人气作者Top40，51CTO年度博主Top12，掘金等平台签约作者，华为云 | 阿里云| 腾讯云等社区优质创作者，全网粉丝合计30w+ ；硬核微信公众号「猿圈奇妙屋」，欢迎你的加入！免费白嫖最新BAT互联网公司面试题、4000G pdf电子书籍、简历模板等海量资料。

–End