深入理解 Java 中的 volatile 和 synchronized 关键字_java 中的 volatile 关键是什么作用?怎样使用它?在 java 中它跟 synchron-CSDN博客

本文链接：https://blog.csdn.net/codingexpert404/article/details/144334402

在多线程编程中，Java 提供了 volatile 和 synchronized 两种关键字来管理线程之间的交互。它们各自具有独特的特性，可以解决不同类型的并发问题。本文将结合两者的特点，深入探讨它们的用法、工作原理及实际开发中的应用场景。

什么是 volatile？

volatile 是一种轻量级的同步机制，用于确保变量的可见性和防止指令重排序。它主要解决以下两大问题：

可见性
当一个线程修改了 volatile 变量的值，其他线程会立即感知到这一变化。
防止指令重排序
通过 volatile 修饰的变量，编译器和处理器不会对其相关指令进行重排序优化。

示例代码

以下代码展示了 volatile 的一个典型使用场景：

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

    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("Thread 1: 正在等待 flag 变为 true...");
            while (!flag) {
                // 循环等待
            }
            System.out.println("Thread 1: 结束等待，flag 已变为 true!");
        }).start();

        new Thread(() -> {
            try {
                Thread.sleep(2000); // 模拟延迟
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            flag = true;
            System.out.println("Thread 2: 已将 flag 设置为 true.");
        }).start();
    }
}

在这段代码中，Thread 1 能够及时感知到 flag 的改变，是因为 flag 被声明为 volatile，避免了线程缓存带来的数据可见性问题。

volatile 的局限性

无法保证原子性
对于复合操作（如 count++），volatile 不能确保线程安全。
不支持锁机制
volatile 仅能保证可见性，无法实现对共享资源的互斥访问。

什么是 synchronized？

synchronized 是 Java 提供的一种重量级同步机制，用于控制线程对共享资源的访问。它不仅可以确保可见性，还可以保证操作的原子性。

Synchronized 的用法

synchronized 可以用在方法上，也可以用在代码块中。

同步方法

public synchronized void incrementCount() {
    count++;
}

使用同步方法时，整个方法被锁定，保证在同一时间只有一个线程可以执行该方法。

同步代码块

public void incrementCount() {
    synchronized (this) {
        count++;
    }
}

同步代码块允许对特定的代码段进行同步，而非锁定整个方法，这样可以提高效率。

volatile 与 synchronized 的对比

特性	`volatile`	`synchronized`
可见性	保证	保证
原子性	不保证	保证
重排序	防止指令重排序	默认防止
性能开销	较低	较高，线程可能需要进入阻塞状态
适用场景	状态标识或简单变量	复杂逻辑或涉及多步操作的场景

结合使用 volatile 和 synchronized

在某些场景下，可以结合使用 volatile 和 synchronized，以便在提供线程安全的同时降低性能开销。例如，在单例模式的双重检查锁（DCL）中，volatile 和 synchronized 的组合是经典用法：

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