线程安全基础

// 一个线程不安全的计数器
public class UnsafeCounter {
    // 共享的可变状态：计数值
    private int count = 0;
 
    // 自增方法——看似简单的一行代码，实则隐藏着线程安全问题
    public void increment() {
        count++; // 这不是原子操作！
    }
 
    // 获取当前计数值
    public int getCount() {
        return count;
    }
}

// count++ 的真实执行过程（伪代码）
int temp = count;    // Step 1: READ  — 从主内存读取 count 的值到线程工作内存
temp = temp + 1;     // Step 2: MODIFY — 在工作内存中执行加一运算
count = temp;        // Step 3: WRITE  — 将新值写回主内存

// String 是不可变的，天生线程安全
// 任何"修改"操作都会返回一个新对象，原对象不受影响
String s = "hello";       // s 指向 "hello" 对象
String s2 = s.concat(" world"); // 创建了新对象 "hello world"
// 此时 s 仍然指向 "hello"，未被修改

// Vector 的"相对线程安全"陷阱
// 即使每个方法都是 synchronized 的，复合操作仍然不安全
Vector<Integer> vector = new Vector<>();
 
// 线程 A：先检查再删除
if (!vector.isEmpty()) {        // 操作 1：检查
    vector.remove(0);           // 操作 2：删除
    // 在操作 1 和操作 2 之间，线程 B 可能已经清空了 vector！
}
 
// 线程 B：清空
vector.clear();                 // 可能在线程 A 的两步之间执行
// 结果：线程 A 的 remove(0) 抛出 ArrayIndexOutOfBoundsException

// 无状态的 Servlet —— 天然线程安全
public class StatelessServlet extends HttpServlet {
 
    // 没有任何实例字段（无状态）
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        // 所有变量都是方法局部变量，存在于线程栈上，不共享
        String name = req.getParameter("name");   // 局部变量，线程私有
        int length = name.length();                // 局部变量，线程私有
        resp.getWriter().write("Hello, " + name);  // 直接使用，无共享状态
    }
}

// 有状态的 Servlet —— 线程不安全！
public class StatefulServlet extends HttpServlet {
 
    // 共享的可变状态！每个请求线程都会访问和修改它
    private int requestCount = 0;
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        requestCount++;  // 危险！多线程并发修改共享可变状态
        resp.getWriter().write("Request #" + requestCount);
    }
}

/**
 * 典型的 check-then-act 竞态条件示例
 * 这个单例实现在多线程环境下是不安全的
 */
public class UnsafeLazyInit {
 
    // 共享变量：单例实例引用
    private static UnsafeLazyInit instance;
 
    // 私有构造器，防止外部直接 new
    private UnsafeLazyInit() {}
 
    /**
     * 获取单例实例 —— 存在竞态条件！
     * 问题出在 check（instance == null）和 act（new）之间不是原子的
     */
    public static UnsafeLazyInit getInstance() {
        // ① CHECK: 检查实例是否为 null
        if (instance == null) {
            // ② ACT: 基于检查结果创建实例
            // 危险窗口：在 ① 和 ② 之间，其他线程可能已经创建了实例
            instance = new UnsafeLazyInit();
        }
        // 返回实例（可能返回不同线程创建的不同对象）
        return instance;
    }
}

/**
 * 文件操作中的 check-then-act 竞态
 * 即使是单线程思维下"正确"的防御性编程，在并发下也可能出问题
 */
public class UnsafeFileOperation {
 
    /**
     * 尝试创建文件 —— 存在 TOCTOU 竞态
     * TOCTOU = Time Of Check to Time Of Use
     */
    public void createFile(String path) throws IOException {
        File file = new File(path);
 
        // CHECK: 检查文件是否已存在
        if (!file.exists()) {
            // ACT: 基于"文件不存在"的假设去创建
            // 危险：在 check 和 act 之间，另一个线程/进程可能已经创建了同名文件
            boolean created = file.createNewFile();
            if (!created) {
                // 走到这里说明竞态条件已经发生
                System.out.println("文件创建失败：竞态条件被触发");
            }
        }
    }
}

/**
 * ConcurrentHashMap 也无法拯救 check-then-act
 * 虽然单个操作是线程安全的，但组合操作不是
 */
public class UnsafeMapAccess {
 
    // 即使用了 ConcurrentHashMap，组合操作仍然不安全
    private final Map<String, List<String>> cache = new ConcurrentHashMap<>();
 
    /**
     * 向缓存中追加值 —— 存在竞态条件
     */
    public void appendValue(String key, String value) {
        // CHECK: 检查 key 是否存在
        if (!cache.containsKey(key)) {
            // ACT: 不存在则创建新列表
            // 两个线程可能同时走到这里，各自创建一个 List，后者覆盖前者
            cache.put(key, new ArrayList<>());
        }
        // 获取列表并追加（前面的 put 可能被覆盖，导致数据丢失）
        cache.get(key).add(value);
    }
 
    /**
     * 正确做法：使用原子化的复合操作
     */
    public void appendValueSafe(String key, String value) {
        // computeIfAbsent 将 check 和 act 合并为一个原子操作
        // 如果 key 不存在，则执行 lambda 创建值并放入 map，整个过程是原子的
        cache.computeIfAbsent(key, k -> new ArrayList<>()).add(value);
    }
}

/**
 * read-modify-write 竞态条件的经典示例
 * count++ 看似一行代码，实际是三步操作
 */
public class UnsafeCounter {
 
    // 共享计数器
    private int count = 0;
 
    /**
     * 自增操作 —— 不是原子的！
     * count++ 在字节码层面等价于：
     *   1. READ:   int temp = this.count;    // 从主存读取当前值
     *   2. MODIFY: temp = temp + 1;          // 在 CPU 寄存器中加 1
     *   3. WRITE:  this.count = temp;        // 将新值写回主存
     * 这三步之间随时可能被线程调度器打断
     */
    public void increment() {
        count++; // 非原子操作！
    }
 
    /**
     * 获取当前计数
     */
    public int getCount() {
        return count;
    }
}

// count++ 对应的字节码指令（简化表示）：
// 
// GETFIELD  count   ← Step 1: READ    从堆内存读取 count 的值压入操作数栈
// ICONST_1          ← 将常量 1 压入操作数栈
// IADD              ← Step 2: MODIFY  栈顶两个值相加，结果压回栈顶
// PUTFIELD  count   ← Step 3: WRITE   将栈顶值写回堆内存的 count 字段
//
// 四条字节码指令，线程可以在任意两条指令之间被挂起

/**
 * 银行账户 —— read-modify-write 竞态的业务场景
 * 余额操作如果不是原子的，钱会"凭空消失"或"凭空出现"
 */
public class UnsafeBankAccount {
 
    // 账户余额（共享可变状态）
    private long balance;
 
    public UnsafeBankAccount(long initialBalance) {
        this.balance = initialBalance;
    }
 
    /**
     * 存款操作 —— 存在 read-modify-write 竞态
     * 与 count++ 本质相同：读余额 -> 加金额 -> 写回余额
     */
    public void deposit(long amount) {
        // READ:   long temp = this.balance;
        // MODIFY: temp = temp + amount;
        // WRITE:  this.balance = temp;
        balance = balance + amount; // 非原子操作
    }
 
    /**
     * 取款操作 —— 同样存在竞态
     */
    public void withdraw(long amount) {
        // 这里还隐含了一个 check-then-act：先检查余额够不够，再扣款
        // 两种竞态模式叠加，问题更严重
        if (balance >= amount) {       // CHECK（可能已过时）
            balance = balance - amount; // ACT（read-modify-write）
        }
    }
 
    public long getBalance() {
        return balance;
    }
}

import java.util.concurrent.atomic.AtomicLong;
 
/**
 * 修复 read-modify-write 竞态的三种常见方式
 */
public class SafeCounterExamples {
 
    // ===== 方式一：synchronized（互斥同步 / 悲观锁）=====
    private long count1 = 0;
 
    /**
     * 使用 synchronized 保证 read-modify-write 的原子性
     * 同一时刻只有一个线程能进入这个方法
     * 简单直接，但在高竞争场景下性能较差
     */
    public synchronized void incrementSync() {
        count1++; // 在锁的保护下，三步操作不会被打断
    }
 
    // ===== 方式二：AtomicLong（非阻塞同步 / 乐观锁）=====
    // AtomicLong 内部使用 CAS（Compare-And-Swap）指令实现原子更新
    private final AtomicLong count2 = new AtomicLong(0);
 
    /**
     * 使用 AtomicLong 的原子自增
     * 底层通过 CPU 的 CAS 指令实现，无需加锁
     * 在中低竞争场景下性能优于 synchronized
     */
    public void incrementAtomic() {
        count2.incrementAndGet(); // 原子操作：读取 + 加1 + 写回 一步完成
    }
 
    // ===== 方式三：LongAdder（分段累加，高竞争场景最优）=====
    // Java 8 引入，专为高并发计数场景设计
    private final java.util.concurrent.atomic.LongAdder count3 =
            new java.util.concurrent.atomic.LongAdder();
 
    /**
     * 使用 LongAdder 的分段累加
     * 内部维护多个 Cell，不同线程累加到不同 Cell 上，减少竞争
     * 最终 sum() 时汇总所有 Cell 的值
     * 在高竞争场景下吞吐量远超 AtomicLong
     */
    public void incrementAdder() {
        count3.increment(); // 几乎无竞争的累加
    }
}

public class TicketSeller {
    private int remainingTickets = 100;
 
    public String sellTicket() {
        if (remainingTickets > 0) {
            remainingTickets--;
            return "出票成功，剩余：" + remainingTickets;
        }
        return "已售罄";
    }
}

public class BankAccount {
    // 共享资源：账户余额，存储在堆内存中，所有线程可见
    private int balance = 1000;
 
    // withdraw 方法中包含临界区
    public void withdraw(int amount) {
        // ===== 临界区开始 =====
        // 这三步操作读写了共享变量 balance
        // 如果多个线程同时执行，会产生竞态条件
        if (balance >= amount) {          // 第一步：读取 balance 并判断（check）
            // 在这个间隙，另一个线程可能已经修改了 balance
            balance = balance - amount;   // 第二步：读取 balance，计算，写回（act）
        }
        // ===== 临界区结束 =====
    }
 
    // deposit 方法中也包含临界区
    public void deposit(int amount) {
        // ===== 临界区开始 =====
        balance = balance + amount;       // read-modify-write 操作
        // ===== 临界区结束 =====
    }
 
    // 这个方法如果只是读取，在某些场景下也可能是临界区的一部分
    public int getBalance() {
        return balance;                   // 单次读取，但可能读到中间状态
    }
}

public class OrderService {
    // 共享资源：订单计数器
    private int orderCount = 0;
    
    public void processOrder(String orderData) {
        // -------- 非临界区开始 --------
        // 参数校验：只读取方法参数（栈上数据），不涉及共享资源
        if (orderData == null || orderData.isEmpty()) {
            throw new IllegalArgumentException("订单数据不能为空");
        }
        
        // 数据解析：局部变量存储在线程栈上，天然线程安全
        String[] parts = orderData.split(",");       // 局部变量，线程私有
        String productName = parts[0];               // 局部变量，线程私有
        int quantity = Integer.parseInt(parts[1]);   // 局部变量，线程私有
        // -------- 非临界区结束 --------
        
        // ======== 临界区开始 ========
        // 只有这一行访问了共享变量 orderCount
        orderCount++;                                // read-modify-write，必须保护
        // ======== 临界区结束 ========
        
        // -------- 非临界区开始 --------
        // 日志输出：使用的都是局部变量
        System.out.println("处理订单: " + productName + " x " + quantity);
        // -------- 非临界区结束 --------
    }
}

// ┌─────────────────────────────────────────────────────────┐
// │                    JVM 堆内存 (Heap)                     │
// │                   所有线程共享区域                         │
// │                                                         │
// │   ┌─────────────────────────────────────┐               │
// │   │  BankAccount 对象实例                │               │
// │   │  ┌─────────────────────────────┐    │               │
// │   │  │  balance = 1000  (共享变量)  │◄───┼── 临界资源    │
// │   │  └─────────────────────────────┘    │               │
// │   └─────────────────────────────────────┘               │
// └──────────────┬──────────────────────┬───────────────────┘
//                │                      │
//        ┌───────▼───────┐      ┌───────▼───────┐
//        │  Thread-1 栈   │      │  Thread-2 栈   │
//        │  (线程私有)    │      │  (线程私有)    │
//        │               │      │               │
//        │  amount = 800 │      │  amount = 500 │
//        │  localVar = ? │      │  localVar = ? │
//        └───────────────┘      └───────────────┘

public class InventoryService {
    private final Map<String, Integer> stock = new HashMap<>();
 
    // 方案一：粗粒度 —— 整个方法作为临界区
    // 优点：实现简单，不容易出错
    // 缺点：并发度极低，所有操作串行化
    public synchronized void updateStock_Coarse(String sku, int delta) {
        // 参数校验（不需要锁保护，但也被锁住了）
        if (sku == null) throw new IllegalArgumentException();
        
        // 日志记录（不需要锁保护，但也被锁住了）
        System.out.println("更新库存: " + sku);
        
        // 真正需要保护的操作
        int current = stock.getOrDefault(sku, 0);
        stock.put(sku, current + delta);
        
        // 通知操作（不需要锁保护，但也被锁住了）
        System.out.println("库存已更新为: " + (current + delta));
    }
 
    // 方案二：细粒度 —— 只锁住真正的临界区
    // 优点：并发度高，非临界区代码可以并行执行
    // 缺点：需要仔细分析哪些代码需要保护
    public void updateStock_Fine(String sku, int delta) {
        // 参数校验 —— 非临界区，无需加锁
        if (sku == null) throw new IllegalArgumentException();
        
        // 日志记录 —— 非临界区，无需加锁
        System.out.println("更新库存: " + sku);
        
        int newValue;
        // 只对访问共享资源的代码加锁
        synchronized (this) {
            // ===== 临界区：只包含对 stock 的读写 =====
            int current = stock.getOrDefault(sku, 0);  // 读取共享 Map
            newValue = current + delta;                 // 计算（可以放在锁外，但值依赖锁内读取）
            stock.put(sku, newValue);                   // 写入共享 Map
            // ===== 临界区结束 =====
        }
        
        // 通知操作 —— 非临界区，使用局部变量 newValue
        System.out.println("库存已更新为: " + newValue);
    }
}

public class CriticalSectionChecklist {
    // ✅ 不是临界区：final 字段，初始化后不可变
    private final String serviceName = "OrderService";
    
    // ✅ 不是临界区：局部变量在方法栈上，线程私有
    public int calculate(int a, int b) {
        int result = a + b;    // 局部变量，安全
        return result;
    }
    
    // ❌ 是临界区：实例字段的 read-modify-write
    private int counter = 0;
    public void increment() {
        counter++;             // 临界区！需要保护
    }
    
    // ❌ 是临界区：复合操作（check-then-act）
    private final Map<String, Object> cache = new ConcurrentHashMap<>();
    public Object getOrCreate(String key) {
        if (!cache.containsKey(key)) {   // check
            cache.put(key, new Object()); // act —— 两步之间可能被其他线程插入
        }
        return cache.get(key);
    }
    // ✅ 正确做法：使用原子复合操作
    public Object getOrCreateSafe(String key) {
        return cache.computeIfAbsent(key, k -> new Object()); // 原子复合操作
    }
}

public class Logger {
    private static int logCount = 0;
    
    public void log(String message) {
        String timestamp = LocalDateTime.now().toString();  // Line 1
        String formatted = "[" + timestamp + "] " + message; // Line 2
        logCount++;                                           // Line 3
        System.out.println(formatted + " (#" + logCount + ")"); // Line 4
    }
}

public class SynchronizedCounter {
    // 共享可变状态
    private int count = 0;
 
    // 方式一：同步实例方法 —— 锁对象是 this（当前实例）
    public synchronized void increment() {
        count++; // 临界区：read-modify-write 操作被互斥保护
    }
 
    // 方式二：同步静态方法 —— 锁对象是 Class 对象（SynchronizedCounter.class）
    public static synchronized void staticMethod() {
        // 所有实例共享同一把锁，粒度最大
    }
 
    // 方式三：同步代码块 —— 显式指定锁对象，粒度最灵活
    private final Object lock = new Object(); // 推荐用专用的 final 锁对象
 
    public void incrementWithBlock() {
        synchronized (lock) {       // monitorenter: 获取 lock 对象的监视器
            count++;                // 临界区
        }                           // monitorexit: 释放 lock 对象的监视器
    }
 
    public int getCount() {
        synchronized (lock) {       // 读操作同样需要同步，保证可见性
            return count;
        }
    }
}

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
 
public class ReentrantLockCounter {
    private int count = 0;
    // 创建一个可重入锁，参数 true 表示使用公平策略
    private final ReentrantLock lock = new ReentrantLock(true);
    // 从锁上派生一个条件变量，用于线程间协调
    private final Condition notZero = lock.newCondition();
 
    public void increment() {
        lock.lock();            // 显式获取锁（阻塞式）
        try {
            count++;            // 临界区
            notZero.signalAll(); // 通知所有等待 count 非零的线程
        } finally {
            lock.unlock();      // 必须在 finally 中释放锁，防止异常导致死锁
        }
    }
 
    public void decrementWhenPositive() throws InterruptedException {
        lock.lock();
        try {
            while (count <= 0) {        // 循环检查条件，防止虚假唤醒(spurious wakeup)
                notZero.await();         // 释放锁并等待，被唤醒后重新获取锁
            }
            count--;                     // 条件满足，安全地执行操作
        } finally {
            lock.unlock();
        }
    }
 
    public boolean tryDecrementWithTimeout() throws InterruptedException {
        // 尝试在 1 秒内获取锁，获取不到就放弃（非阻塞式）
        if (lock.tryLock(1, java.util.concurrent.TimeUnit.SECONDS)) {
            try {
                if (count > 0) {
                    count--;
                    return true;
                }
                return false;
            } finally {
                lock.unlock();
            }
        }
        return false;   // 超时未获取到锁，返回失败
    }
}

// CAS 的伪代码表示（实际由 CPU 单条指令完成，不可分割）
boolean compareAndSwap(int[] memory, int address, int expected, int newValue) {
    int currentValue = memory[address];     // 读取当前值
    if (currentValue == expected) {          // 比较：当前值是否等于期望值？
        memory[address] = newValue;          // 相等则更新
        return true;                         // 返回成功
    }
    return false;                            // 不相等，说明被其他线程修改过，返回失败
}

import java.util.concurrent.atomic.AtomicInteger;
 
public class CasCounter {
    // AtomicInteger 内部持有一个 volatile int value
    // 所有操作都通过 CAS 实现，无需加锁
    private final AtomicInteger count = new AtomicInteger(0);
 
    public void increment() {
        // incrementAndGet() 内部实现等价于：
        // do {
        //     int expected = value;           // 读取当前值
        //     int newValue = expected + 1;    // 计算新值
        // } while (!cas(expected, newValue)); // CAS 失败则自旋重试
        count.incrementAndGet();
    }
 
    public int getCount() {
        return count.get();  // volatile 读，保证可见性
    }
 
    // 手动演示 CAS 自旋模式
    public void safeUpdate(int delta) {
        int oldValue;                           // 保存旧值
        int newValue;                           // 保存计算后的新值
        do {
            oldValue = count.get();             // 步骤1：读取当前值
            newValue = oldValue + delta;        // 步骤2：基于当前值计算新值
        } while (!count.compareAndSet(         // 步骤3：CAS 尝试更新
                oldValue,                       //   期望值 = 刚才读到的旧值
                newValue                        //   新值 = 计算结果
        ));                                     // 如果失败（被其他线程抢先修改），循环重试
    }
}

import java.util.concurrent.atomic.AtomicStampedReference;
 
public class AbaDemo {
    // AtomicStampedReference 为每个值附加一个 int 类型的版本号(stamp)
    // 初始值为 "A"，初始版本号为 0
    private final AtomicStampedReference<String> ref =
            new AtomicStampedReference<>("A", 0);
 
    public void safeUpdate() {
        int[] stampHolder = new int[1];                 // 用数组接收当前版本号
        String current = ref.get(stampHolder);          // 同时获取值和版本号
        int currentStamp = stampHolder[0];              // 取出版本号
 
        // CAS 时同时比较值和版本号，两者都匹配才更新
        boolean success = ref.compareAndSet(
                current,                                // 期望的引用值
                "B",                                    // 新的引用值
                currentStamp,                           // 期望的版本号
                currentStamp + 1                        // 新的版本号（递增）
        );
        // 即使值从 A -> B -> A，版本号也从 0 -> 1 -> 2
        // 所以期望版本号 0 不匹配当前版本号 2，CAS 会失败
    }
}

import java.util.concurrent.atomic.LongAdder;
 
public class HighContentionCounter {
    // LongAdder 内部维护一个 base 值和一个 Cell 数组
    // 低竞争时直接 CAS base；高竞争时，不同线程 CAS 不同的 Cell
    // 最终 sum() 时将 base + 所有 Cell 的值汇总
    private final LongAdder adder = new LongAdder();
 
    public void increment() {
        adder.increment();  // 内部自动选择 CAS base 还是 CAS 某个 Cell
    }
 
    public long getCount() {
        return adder.sum(); // 注意：sum() 不是原子快照，适合统计场景
    }
}

public class StackConfinementDemo {
 
    // 这个方法是线程安全的，即使被多个线程同时调用
    public int calculateSum(int[] numbers) {
        // sum 是局部变量，存储在当前线程的栈帧中
        // 每个线程调用此方法时，都有自己独立的 sum 副本
        int sum = 0;
 
        // tempList 也是局部变量，引用和对象都不会逃逸
        // 虽然 ArrayList 本身不是线程安全的，但这里完全没问题
        List<Integer> tempList = new ArrayList<>();
 
        for (int num : numbers) {       // numbers 是方法参数，也在栈上
            sum += num;                  // 只操作局部变量，无需同步
            tempList.add(num);           // ArrayList 只被当前线程访问
        }
 
        // 返回基本类型值（值拷贝），不存在共享问题
        return sum;
 
        // 注意：如果这里返回 tempList 的引用，
        // 并且调用者将其存储到共享字段中，栈封闭就被打破了！
    }
}

public class BrokenConfinement {
    private List<Integer> sharedList;    // 共享字段
 
    public void process(int[] numbers) {
        List<Integer> localList = new ArrayList<>();  // 局部变量
        for (int num : numbers) {
            localList.add(num);
        }
        // 危险！局部变量的引用被赋值给共享字段，栈封闭被打破
        this.sharedList = localList;
        // 此后其他线程可以通过 sharedList 访问这个 ArrayList
        // 而 ArrayList 不是线程安全的 —— 竞态条件出现
    }
}

public class ThreadLocalDemo {
 
    // 每个线程都有自己独立的 SimpleDateFormat 实例
    // SimpleDateFormat 是非线程安全的，但通过 ThreadLocal 隔离后完全安全
    private static final ThreadLocal<SimpleDateFormat> dateFormatter =
            ThreadLocal.withInitial(                    // 工厂方法，延迟初始化
                    () -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
            );
 
    // 用 ThreadLocal 维护每个线程的用户上下文
    private static final ThreadLocal<UserContext> userContext =
            new ThreadLocal<>();
 
    public String formatDate(Date date) {
        // get() 返回当前线程的专属副本，无需同步
        return dateFormatter.get().format(date);
    }
 
    public void setUser(UserContext ctx) {
        userContext.set(ctx);    // 设置当前线程的用户上下文
    }
 
    public UserContext getUser() {
        return userContext.get(); // 获取当前线程的用户上下文
    }
 
    // 非常重要：在线程池场景下，必须在任务结束时清理 ThreadLocal
    public void cleanup() {
        dateFormatter.remove();  // 移除当前线程的副本，防止内存泄漏
        userContext.remove();    // 线程池中线程会被复用，不清理会导致数据串线程
    }
}

// 内存泄漏的引用链：
// Thread -> ThreadLocalMap -> Entry -> Value (强引用，无法回收)
//                              |
//                              +-> Key (WeakReference, 已被 GC 回收, 变为 null)

public class ThreadLocalBestPractice {
 
    private static final ThreadLocal<Connection> connectionHolder =
            ThreadLocal.withInitial(() -> {
                // 每个线程初始化自己的数据库连接
                return DriverManager.getConnection("jdbc:mysql://localhost/db");
            });
 
    public void executeQuery(String sql) {
        Connection conn = connectionHolder.get();   // 获取当前线程的连接
        try {
            // 使用连接执行查询...
            PreparedStatement ps = conn.prepareStatement(sql);
            ps.executeQuery();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            // 关键：任务结束后必须清理
            connectionHolder.remove();              // 移除当前线程的副本
        }
    }
}

public class InheritableDemo {
    // 父线程设置的值会自动拷贝给子线程
    private static final InheritableThreadLocal<String> traceId =
            new InheritableThreadLocal<>();
 
    public static void main(String[] args) {
        traceId.set("TRACE-001");                   // 父线程设置 traceId
 
        Thread child = new Thread(() -> {
            // 子线程可以读取到父线程的值（创建子线程时拷贝）
            System.out.println(traceId.get());       // 输出: TRACE-001
        });
        child.start();
    }
}

public class IdGenerator {
    private static long id = 0;
 
    public static long nextId() {
        return ++id;
    }
}

public class ConnectionPool {
    private static ConnectionPool instance; // 共享可变状态
 
    public static ConnectionPool getInstance() {
        if (instance == null) {           // 步骤1: check
            instance = new ConnectionPool(); // 步骤2: act
        }
        return instance;
    }
}

public class ConnectionPool {
    // volatile 防止指令重排序，确保 instance 引用指向的对象已完成初始化
    private static volatile ConnectionPool instance;
 
    public static ConnectionPool getInstance() {
        if (instance == null) {                    // 第一次检查：无锁快速路径
            synchronized (ConnectionPool.class) {  // 加锁进入临界区
                if (instance == null) {            // 第二次检查：防止重复创建
                    instance = new ConnectionPool();
                }
            }
        }
        return instance;
    }
}