Java 并发编程：volatile 关键字介绍与使用

一只蜗牛儿

于 2024-10-06 17:55:06 发布

阅读量581

点赞数 10

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_42978535/article/details/142729802

版权

在 Java 并发编程中，确保线程安全是一个至关重要的方面。volatile 关键字作为一种轻量级的同步机制，能够帮助开发者实现对共享变量的可见性。本文将详细介绍 volatile 关键字的使用场景、工作原理以及与其他同步机制的比较，结合丰富的代码示例，帮助你深入理解其在多线程环境中的作用。

一、什么是 `volatile` 关键字

在 Java 中，volatile 是一个修饰符，用于声明一个变量的值可能会被多个线程同时访问和修改。通过使用 volatile 关键字，可以确保：

可见性：当一个线程修改了 volatile 变量的值，其他线程能够立即看到这个修改。
禁止指令重排序：编译器和 CPU 在执行代码时，可能会为了优化而重排序操作，但使用 volatile 变量时，保证了该变量的操作不会被重排序。

二、`volatile` 的特性

可见性：
- volatile 变量的值在主内存中更新后，其他线程能够立即读取到最新的值。相较于普通变量，volatile 能够防止线程间的缓存不一致。
禁止指令重排序：
- 对 volatile 变量的写操作在它前面的所有操作都不会被重排序，反之亦然。这意味着 volatile 变量的操作不会被优化成可能导致错误的顺序。
不具备原子性：
- volatile 关键字保证了可见性和禁止指令重排序，但并不保证操作的原子性。因此，在执行复合操作（如自增）时，仍需使用其他同步机制。

三、`volatile` 的使用场景

状态标志：在多线程环境中，使用 volatile 变量作为状态标志，可以确保一个线程的状态更改能够被其他线程及时看到。
单例模式：在单例模式的实现中，volatile 变量可以防止线程在实例化对象时的重排序问题，确保只创建一个实例。
简单的缓存：对于某些简单的缓存场景，使用 volatile 可以减少同步的开销，提高性能。

四、代码示例

4.1 示例 1：使用 `volatile` 的状态标志

public class VolatileExample {
    private static volatile boolean running = true;

    public static void main(String[] args) {
        Thread worker = new Thread(() -> {
            while (running) {
                // 执行一些任务
                System.out.println("Worker thread is running...");
            }
            System.out.println("Worker thread is stopped.");
        });

        worker.start();

        // 主线程等待一段时间后停止 worker
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        running = false; // 设置停止标志
        System.out.println("Main thread is stopping the worker thread.");
    }
}

代码解析

在这个示例中，running 是一个 volatile 变量。worker 线程不断检查 running 的值，直到主线程将其设置为 false。通过使用 volatile，我们确保 worker 线程能够看到 running 的最新值。

4.2 示例 2：使用 `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;
    }
    
    public void doSomething() {
        System.out.println("Doing something in singleton instance.");
    }
}

public class SingletonTest {
    public static void main(String[] args) {
        // 测试单例
        Singleton singleton = Singleton.getInstance();
        singleton.doSomething();
    }
}

代码解析

在这个单例模式的实现中，我们使用 volatile 修饰 instance 变量，以防止在多线程环境下的重排序问题。即使在高并发情况下，getInstance() 方法也能确保只创建一个实例。

五、`volatile` 与其他同步机制的比较

特性	`volatile`	`synchronized`	`Lock`
可见性	是	是	是
原子性	否	是	是
性能	快速	较慢	较快
锁的粒度	无	方法或代码块级别	可以自定义
适用场景	状态标志、单例模式	复杂操作、临界区	高级同步、可重入