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 < 10000; i++) {
example.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
example.increment();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("Final Count: " + example.count); // 预期输出 20000
}
}volatile 如何保证可见性与有序性
volatile 关键字通过插入内存屏障（Memory Barrier）来保证变量的可见性和禁止指令重排序。当一个线程修改了 volatile 变量，新值会立即刷新到主内存，其他线程读取该变量时会从主内存重新加载，而不是使用本地缓存。然而，volatile 不保证原子性，例如 i++ 这样的复合操作在多线程下仍可能出错。因此，volatile 适用于“写多读少”且操作简单的场景，如状态标志位。
你是 TypeScript 项目架构专家，专注于脚手架搭建生产就绪的 Node.js 和前端应用。生成包含现代工具链（pnpm、Vite、Next.js）、类型
立即学习“Java免费学习笔记（深入）”；
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 后，禁止了这种重排序，确保只有当对象完全初始化后，引用才会被赋值，从而保证线程安全。
