Java中volatile和synchronized的使用

本文介绍了Java中synchronized和volatile关键字的使用方法及应用场景。synchronized通过加锁机制确保线程安全,而volatile则保证了变量的可见性和禁止指令重排序,但不提供原子性保证。

在开发当中使用多线程的,经常会用到synchronized和volatitle。接下来就讲讲他们的使用场景。

synchronized

java关键字,方法用到这个关键字则对这个方法进行加锁。一次只能进入一个线程,其他线程只能等待或执行其他没有加锁的方法。等到这个线程完成后,下个线程才能进去。这样保证数据的原子性,同时性能也就下降。

volatile

java关键字,用来声明变量。

1.可见性

保证所有的线程的可见性,当一个线程修改了这个变量的值,volatile 保证了新值能立即同步到主内存,这样其他线程获取的是最新的值,保证了这个变量共享。

2.禁止指令重排序

指定重排序会涉及到编译器和处理器,单线程再跑程序的时候处理器会按照编译器的顺序执行,当多个线程在跑的时候,处理器就不按照编译器的顺序来,自己会重排序。(什么是指令重排序:是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理)

3.原子性

volatile不保证原子性,会存在线程安全问题。

synchronized例子:

package com.company;

public class Main extends Thread {

    //剩余票数
    private  int ticket = 1000;
    //购买票数
    private int buy = 0;

    @Override
    public void run() {
        long startTime = System.currentTimeMillis();
        while (ticket > 0) {
            synchronized (this) {
                if (ticket > 0) {
                    ticket--;
                    buy++;
                    System.out.println("线程名" + Thread.currentThread().getName() + "余票:" + ticket + "," + "出售:" + buy);
                }
            }
        }
        System.out.println("消耗:" + (System.currentTimeMillis() - startTime) + "ms");
    }

    public static void main(String[] args) {
        System.out.println("主线程:" + Thread.currentThread().getName());
        Main main = new Main();
        new Thread(main).start();

        new Thread(main).start();
        new Thread(main).start();
        new Thread(main).start();
        new Thread(main).start();
    }
}

volatile例子:

package com.company;

public class Main extends Thread {

    //剩余票数
    private volatile  int ticket = 1000;
    //购买票数
    private int buy = 0;

    @Override
    public void run() {
        long startTime = System.currentTimeMillis();
        while (ticket > 0) {
           // synchronized (this) {
                if (ticket > 0) {
                    ticket--;
                    buy++;
                    System.out.println("线程名" + Thread.currentThread().getName() + "余票:" + ticket + "," + "出售:" + buy);
                }
           // }
        }
        System.out.println("消耗:" + (System.currentTimeMillis() - startTime) + "ms");
    }

    public static void main(String[] args) {
        System.out.println("主线程:" + Thread.currentThread().getName());
        Main main = new Main();
        new Thread(main).start();

        new Thread(main).start();
        new Thread(main).start();
        new Thread(main).start();
        new Thread(main).start();
    }
}

 

<think>嗯,用户想了解Javavolatilesynchronized的关键区别以及使用场景。这个问题很基础但特别重要,涉及到并发编程的核心概念。从用户之前的引用内容看,ta显然已经做过一些功课,但还需要更系统的对比。用户引用的三份资料其实已经涵盖了主要知识点:[^1]提到了可见性原子性的基础区别,[^2]用公告板的比喻形象说明了volatile的可见性机制,[^3]则详细列出了技术细节使用限制。不过这些信息比较零散,需要帮ta整合成体系。值得注意几个技术要点:首先是"不满足条件时volatile会出什么问题"需要具体说明。比如当违反"写入不依赖当前值"规则时,用volatile修饰的计数器即便++操作也会出错,因为自增实际上是read-modify-write三步操作。这个得用例子说明才直观。其次是内存语义的深层区别。volatile实际是通过内存屏障禁止指令重排序的,而synchronized是互斥锁机制。这导致它们的开销差异很大:在仅需可见性保障时,volatile的性能能比synchronized高几个数量级。用户应该会关心实际编码场景。除了常见的状态标志位,可以补充DCL(双重检查锁)中volatile的经典用法。而对于synchronized,要强调它不仅能保护变量,还能保护代码块——比如在账户转账时保证"查询余额-扣款-写入"整个过程的原子性。安全问题也要提醒:比如用volatile修饰对象引用时,只能保证引用地址的可见性,对象内部字段的修改依然可能存在线程安全问题。这点很多开发者容易忽略。最后响应速度的对比很有趣。参考资料提到volatile不会阻塞线程,但在实际高并发场景下,频繁的缓存失效可能导致隐性性能损耗。而synchronizedJava6优化后,偏向锁/轻量级锁等机制已经大幅降低了阻塞开销。</think> 好的,我们来详细梳理一下 Java 中 `volatile` `synchronized` 这两个并发关键字的核心区别、工作原理以及适用场景。 以下是 `volatile` `synchronized` 的主要区别总结: | **对比维度** | **`volatile`** | **`synchronized`** | |------------|---------------|-------------------| | **核心作用** | 保证变量修改的可见性 | 保证变量修改的原子性与可见性 | | **内存语义** | 直接读写主内存 | 锁定时获取主内存最新值,解锁前写入主内存 | | **原子性保证** | ✘ 无 | ✓ 有(可以保证复合操作的原子性) | | **可见性保证** | ✓ 有 | ✓ 有(比volatile更严格) | | **排他性/互斥** | ✘ 无 | ✓ 有(一次只允许一个线程进入) | | **阻塞** | ✘ 不会引起阻塞 | ✓ 可能引起阻塞 | | **适用级别** | 变量级 | 变量、方法、代码块、类级 | | **性能开销** | 相对较低 | 相对较高(尤其在高竞争下) | ## 详细解析 1. **核心作用 (Key Purpose)** * **`volatile`**: **唯一职责是保证变量的可见性 (visibility)**。 * 当一个线程修改了一个 `volatile` 变量的值时,这个新值会**立即**被刷新回主内存(而不是仅仅留在工作内存/CPU缓存)。 * 当其他线程随后读取这个 `volatile` 变量时,它们会**强制**从主内存重新加载最新的值(而不是使用本地缓存中的旧值)。 * **禁止指令重排序优化**:`volatile` 写操作前(StoreStore)写操作后(StoreLoad)的内存屏障,以及读操作前(LoadLoad)读操作后(LoadStore)的内存屏障,限制了编译器处理器对指令的重排序。 * **`synchronized`**: **核心是提供互斥访问 (mutual exclusion) 并由此带来原子性可见性保证**。 * **互斥性 (Mutual Exclusion)**:当一个线程进入一个 `synchronized` 方法或代码块(获取锁),其他尝试进入**同一个锁**(基于对象或类)的 `synchronized` 方法/代码块的线程会被阻塞(挂起)。 * **原子性 (Atomicity)**:由互斥性保证。它确保了一个线程在执行 `synchronized` 代码块中的所有语句时,不会被其他线程干扰,从而将整个代码块视为一个原子操作。这对于需要多个步骤的操作至关重要(如 `i++` 这个 read-modify-write 操作)。 * **可见性 (Visibility)**:是互斥性带来的副产品,比 `volatile` 更严格: * 线程在进入 `synchronized` 代码块(获取锁)时,会**清空工作内存**,强制从主内存重新加载共享变量的值,确保看到最新的状态。 * 线程在退出 `synchronized` 代码块(释放锁)时,会把修改过的变量值**强制刷新回主内存**。这使得随后获取同一把锁的其他线程能看到这些修改。 2. **原子性保证 (Atomicity Guarantee)** * **`volatile`**:**不提供任何原子性保证**。这是它们最核心的区别之一。 * 对 `volatile` 变量进行的单次读或写操作本身是原子的(如 `volatile int x; x = 10;`)。 * 但多个操作的复合操作(即使是简单的 `v++`,它包含了读取 `v`、+1、写回 `v` 三个操作)**不是原子**的。如果多个线程试图同时执行 `v++`,仍然会发生数据竞争导致结果不正确(即使 `v` 是 `volatile`)。 * **`synchronized`**:**提供了原子性保证**。它通过锁机制,确保了一个线程可以完整地执行被锁保护的一段代码(即使包含多个操作,如读取、计算、写入),而不会被其他线程打断。这个代码块中的操作对其它线程来说是不可分割的,就像是一个操作一样。 3. **阻塞 (Blocking)** * **`volatile`**:**访问 `volatile` 变量永远不会引起线程阻塞**。它只涉及内存访问,不涉及锁获取线程挂起/唤醒。 * **`synchronized`**:**获取锁的过程可能导致线程阻塞**。如果一个线程尝试进入一个 `synchronized` 块,而所需的锁(对象监视器锁)已被其他线程持有,那么该线程会被挂起,进入阻塞状态(BLOCKED),直到锁被释放并唤醒它。这是实现互斥的核心机制。这也是 `synchronized` 在某些高竞争场景下性能开销的来源。 4. **范围级别 (Applicability Level)** * **`volatile`**:**只能修饰成员变量(实例变量、类变量)**。 * **`synchronized`**:**可以修饰代码块、方法(实例方法、静态方法)、甚至类**(通过锁类对象)。适用性更广泛。 5. **性能开销 (Performance)** * **`volatile`**:**开销相对较低**。因为它不需要获取释放锁,不会引起线程上下文切换。 * **`synchronized`**:**开销相对较高**。现代 JVM (Java 6+) 对 `synchronized` 做了大量优化(如偏向锁、轻量级锁、适应性自旋锁、锁膨胀),但相比 `volatile`,它最终涉及到锁竞争管理(可能导致线程挂起唤醒)内存屏障,在高度竞争的情况下开销显著增加。 ## 使用场景 (Use Cases) * **`volatile` 适用场景 (When to use `volatile`)**: * **简单的状态标志位 (Simple Status Flags)**:这是最经典的场景。需要一个 `volatile boolean` 变量(如 `shutdownRequested`)来通知线程从循环中退出或其他简单状态变更。 ```java volatile boolean shutdownRequested = false; void shutdown() { shutdownRequested = true; } void doWork() { while (!shutdownRequested) { // ... do tasks ... } } ``` * **单次安全发布 (Safe Publication - one-time)**:利用 `volatile` 的禁止重排序特性,安全地发布一个构造完整的对象引用(需要满足“初始化期间没有逸出”等条件)。 ```java public class Singleton { private static volatile Singleton instance; public static Singleton getInstance() { if (instance == null) { synchronized(Singleton.class) { if (instance == null) { instance = new Singleton(); // volatile write after initialization } } } return instance; } // ... private constructor ... } ``` * **对变量的读操作远多于写操作**:在这种情况下,避免互斥锁的开销更重要,同时 `volatile` 能保证读到的是最新值。 * **满足条件**:操作必须是单步原子写(如直接赋值 `x = y`),且不依赖于变量的当前值(不能用 `x++`),并且变量不参与与其他变量的不变性约束(Invariants)。[^3] * **`synchronized` 适用场景 (When to use `synchronized`)**: * **复合操作的原子性保证 (Atomic Compound Actions)**:任何需要多个步骤且必须作为一个整体执行的操作,如 `i++` (即使 `i` 是 `volatile` 也不行),转账操作(读取A余额、读取B余额、扣A加B、写回A、写回B)。 ```java class Account { private double balance; public synchronized void deposit(double amount) { balance += amount; // atomic operation protected by lock } public synchronized void withdraw(double amount) { balance -= amount; // atomic operation protected by lock } } ``` * **读写操作都需要同步控制 (Critical Sections with Read-Modify-Write)**:当不仅需要写操作同步,读操作也需要查看最新一致状态并可能与写互斥的场景。 * **维护不变性约束 (Maintaining Invariants)**:当多个共享变量之间存在约束关系时(例如,两个变量的值必须保持某种比例关系),访问这些变量的操作需要在一个临界区内完成,以保证约束不被破坏。[^3] * **需要更严格的可见性保证**:虽然 `volatile` 也提供可见性,但 `synchronized` 在进入/退出块时的内存屏障提供了更全的"发生在关系"保证。 * **当 `volatile` 的使用条件不满足时**:特别是需要原子性保证或存在复合操作时,必须使用 `synchronized` (或显式锁)。 ## 核心区别再强调 * **`volatile` = 可见性 + 禁止重排序 (Visibility + No-Reordering)** * **`synchronized` = 互斥性 + 原子性 + 可见性 (Mutual Exclusion + Atomicity + Visibility)** ## 相关问题
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值