volatile 和 Lock 在并发控制上的核心区别是什么

volatile 和 lock 的核心区别在于：lock 提供互斥锁机制，确保同一时刻只有一个线程能执行临界区代码，从而实现原子性和可见性；而 volatile 仅保证变量的可见性和有序性，不保证复合操作的原子性。简单来说，lock 是重量级的互斥同步工具，适合保护复杂状态或代码块；volatile 是轻量级的变量修饰符，适合用于标志位、单例模式等简单场景。

Lock 如何实现互斥与可见性

Lock（如 ReentrantLock）通过底层 CAS 操作和 AQS（AbstractQueuedSynchronizer）实现线程的互斥访问。当线程获取锁失败时，会被阻塞并挂起，直到锁被释放。同时，Lock 在释放锁时会执行内存屏障（Memory Barrier），强制将工作内存中的变量刷新到主内存，从而保证可见性。这种机制适用于需要保护多个变量或执行复杂逻辑的场景。

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 获取锁
        try {
            // 临界区：保证原子性
            int temp = count;
            temp = temp + 1;
            count = temp;
        } finally {
            lock.unlock(); // 释放锁，触发内存屏障，保证可见性
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LockExample example = new LockExample();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i  {
            for (int i = 0; i <h2>volatile 如何保证可见性与有序性</h2><p>volatile 关键字通过插入内存屏障（Memory Barrier）来保证变量的可见性和禁止指令重排序。当一个线程修改了 volatile 变量，新值会立即刷新到主内存，其他线程读取该变量时会从主内存重新加载，而不是使用本地缓存。然而，volatile 不保证原子性，例如 <code>i++</code> 这样的复合操作在多线程下仍可能出错。因此，volatile 适用于“写多读少”且操作简单的场景，如状态标志位。</p><div class="aritcle_card flexRow artxards">
											<div class="artcardd flexRow">
												<a class="aritcle_card_img" rel="nofollow" href="/xiazai/skill12540" title="javascript-typescript-typescript-scaffold"><img
														src="https://img.php.cn/upload/skill/001/246/273/6adaf20e352aa140.jpg" alt="javascript-typescript-typescript-scaffold" onerror="this.onerror='';this.src='/static/lhimages/moren/morentu.png'" ></a>
												<div class="aritcle_card_info flexColumn">
													<a rel="nofollow" href="/xiazai/skill12540" title="javascript-typescript-typescript-scaffold" class="overflowclass">javascript-typescript-typescript-scaffold</a>
													<p class="overflowclass">你是 TypeScript 项目架构专家，专注于脚手架搭建生产就绪的 Node.js 和前端应用。生成包含现代工具链（pnpm、Vite、Next.js）、类型</p>
												</div>
												<a rel="nofollow" href="/xiazai/skill12540" title="javascript-typescript-typescript-scaffold" class="aritcle_card_btn flexRow flexcenter"><b></b><span>下载</span>
												</a>
											</div>
										</div><p><img src="https://img.php.cn/upload/article/001/242/473/179444705416558.png?x-oss-process=image/resize,p_40" alt="Java volatile 中 volatile 和 Lock 有什么区别"></p><pre class="brush:php;toolbar:false;">public class VolatileExample {
    private volatile boolean running = true;

    public void stop() {
        running = false; // 写入 volatile 变量，立即刷新到主内存
    }

    public void run() {
        while (running) { // 读取 volatile 变量，始终从主内存加载
            // 执行任务
        }
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileExample example = new VolatileExample();
        Thread t = new Thread(example::run);
        t.start();
        Thread.sleep(1000);
        example.stop(); // 停止线程
        t.join();
        System.out.println("Thread stopped.");
    }
}

volatile 在双重检查锁定（DCL）单例模式中如何解决指令重排问题

在双重检查锁定（Double-Checked Locking, DCL）单例模式中，如果 instance 变量没有声明为 volatile，可能会因为指令重排序导致其他线程获取到未完全初始化的对象。具体来说，对象创建过程分为三步：分配内存、初始化对象、将引用指向内存地址。如果没有 volatile，JVM 可能将第二步和第三步重排序，导致其他线程在初始化完成前就拿到一个空对象引用。加上 volatile 后，禁止了这种重排序，确保只有当对象完全初始化后，引用才会被赋值，从而保证线程安全。

Java免费学习笔记：立即使用
解锁 Java 大师之旅：从入门到精通的终极指南