// 经典的可见性问题示例
public class VisibilityDemo {
    private static boolean flag = false;  // 没有 volatile！

    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            while (!flag) { }  // 可能永远看不到 flag 变为 true
            System.out.println("Thread B sees flag = true");
        }).start();

        Thread.sleep(100);
        flag = true;  // 主线程修改了，但子线程可能永远看不到
        System.out.println("Main set flag = true");
    }
}

int a = 1;   // ①
int b = 2;   // ②
int c = a + b; // ③
// ①和②可以互换顺序，但③必须在①②之后 —— 这就是重排序的边界

// volatile 不保证原子性的经典反例
private static volatile int count = 0;

public static void main(String[] args) throws Exception {
    for (int i = 0; i < 10; i++) {
        new Thread(() -> {
            for (int j = 0; j < 10000; j++) count++;
        }).start();
    }
    Thread.sleep(1000);
    System.out.println("count = " + count);  // 几乎一定 < 100000
}

volatile boolean v;
v = true;   // 写操作：插入 StoreStore + StoreLoad 屏障
boolean b = v; // 读操作：插入 LoadLoad + LoadStore 屏障

// 最经典的 volatile 用法 —— 停止标志
private volatile boolean running = true;

public void shutdown() { running = false; }

public void doWork() {
    while (running) {
        // 处理业务逻辑...
    }
}

public class Singleton {
    private static volatile Singleton instance;  // 必须加 volatile！

    public static Singleton getInstance() {
        if (instance == null) {                    // 第一次检查（无锁）
            synchronized (Singleton.class) {
                if (instance == null) {            // 第二次检查（有锁）
                    instance = new Singleton();    // ⚠️ 这里不是原子操作！
                }
            }
        }
        return instance;
    }
}

private volatile int[] arr = new int[10];
arr[0] = 1;  // ❌ 这不是 volatile 写！只保证了 arr 引用的可见性
              //    arr[0] 的修改对其他线程不一定可见

// 1. 修饰实例方法 —— 锁的是当前实例对象（this）
public synchronized void method() { ... }

// 2. 修饰静态方法 —— 锁的是当前类的 Class 对象
public static synchronized void staticMethod() { ... }

// 3. 修饰代码块 —— 锁的是指定对象
synchronized (lockObject) { ... }

无锁 ──(第一次获取)──▶ 偏向锁 ──(竞争出现)──▶ 轻量级锁 ──(自旋失败)──▶ 重量级锁
  │                      │                     │                       │
  │  CAS 设置 ThreadID   │  CAS 替换 Mark Word  │  自旋+CAS             │  OS mutex
  │  无竞争时零开销      │  少量竞争           │  短时间竞争           │  上下文切换

// 锁消除：锁的对象是局部变量，不可能被外部线程访问
public void lockElimination() {
    StringBuffer sb = new StringBuffer();  // StringBuffer 方法都是 synchronized 的
    sb.append("a").append("b");            // JIT 发现 sb 是局部的 → 直接去掉所有锁
}

// 锁粗化：循环体内频繁加锁解锁 → 合并为一次
for (int i = 0; i < 1000; i++) {
    synchronized (lock) { ... }  // JIT 可能合并为 synchronized(lock) { for(...) {...} }
}

// CAS(V, Expected, NewValue)
// 如果内存值 V == 期望值 Expected，则将 V 更新为 NewValue，否则什么都不做
boolean CAS(V, Expected, NewValue) {
    if (V == Expected) {
        V = NewValue;
        return true;   // 成功
    }
    return false;      // 失败，V 已被其他线程修改
}

// AtomicInteger.getAndIncrement() 的核心调用：
// unsafe.compareAndSwapInt(this, valueOffset, expect, update)
//
// 最终汇编：
// lock cmpxchg [addr], reg   ← lock 前缀保证多核原子性

线程1 读取值 A（准备 CAS 为 C）
线程2 把 A 改成 B
线程3 又把 B 改回 A
线程1 执行 CAS(A, C) → 成功！但实际上中间已经变了两次

// AtomicStampedReference —— 带版本号的引用
AtomicStampedReference<String> asr = new AtomicStampedReference<>("A", 0);

// CAS 时同时比较值和版本号
int[] stampHolder = new int[1];
String ref = asr.get(stampHolder);       // ref="A", stamp=0
boolean ok = asr.compareAndSet(ref, "C", stampHolder[0], stampHolder[0] + 1);
//                              期望引用  新引用  期望版本  新版本

// AtomicMarkableReference —— 带布尔标记的引用（简化版，只关心"变没变过"）
AtomicMarkableReference<String> amr = new AtomicMarkableReference<>("A", false);
amr.compareAndSet("A", "B", false, true);  // 同时比较引用和标记

// LongAdder —— 高并发下的计数器替代方案（JDK 8+）
LongAdder counter = new LongAdder();
counter.increment();  // 内部分散到多个 Cell，减少 CAS 竞争
long sum = counter.sum();  // 汇总所有 Cell

java.util.concurrent.atomic
├── 基本类型
│   ├── AtomicInteger
│   ├── AtomicLong
│   └── AtomicBoolean
├── 数组类型
│   ├── AtomicIntegerArray
│   ├── AtomicLongArray
│   └── AtomicReferenceArray<E>
├── 引用类型
│   ├── AtomicReference<V>
│   ├── AtomicStampedReference<V>
│   └── AtomicMarkableReference<V>
├── 字段更新器
│   ├── AtomicIntegerFieldUpdater<T>
│   ├── AtomicLongFieldUpdater<T>
│   └── AtomicReferenceFieldUpdater<T,V>
└── 累加器（JDK 8+）
    ├── LongAdder
    ├── DoubleAdder
    ├── LongAccumulator
    └── DoubleAccumulator

public final int getAndIncrement() {
    return getAndAdd(1);
}

public final int getAndAdd(int delta) {
    // U = sun.misc.Unsafe 实例
    // valueOffset = 字段 value 在对象内存中的偏移量
    return U.getAndAddInt(this, VALUE, delta);
}

// Unsafe.getAndAddInt —— CAS 自旋循环
public final int getAndAddInt(Object o, long offset, int delta) {
    int prev;
    int next;
    do {
        prev = getIntVolatile(o, offset);  // 读取当前值（volatile 读）
        next = prev + delta;               // 计算新值
    } while (!compareAndSwapInt(o, offset, prev, next));  // CAS 更新，失败则重试
    return prev;  // 返回旧值
}

// 场景：想对一个第三方类的某个 volatile 字段做原子操作，
// 但不能修改它的源码
class Student {
    volatile int score;
}

AtomicIntegerFieldUpdater<Student> updater =
    AtomicIntegerFieldUpdater.newUpdater(Student.class, "score");

Student s = new Student();
updater.set(s, 80);          // 相当于 s.score = 80（原子写）
int old = updater.getAndIncrement(s);  // 原子的 s.score++

AQS 核心架构：
┌─────────────────────────────────────┐
│         AbstractQueuedSynchronizer   │
│                                      │
│  ┌──────────┐    ┌───────────────┐  │
│  │  state   │    │  CLH 队列      │  │
│  │ (int,    │    │  (FIFO 双向链表)│  │
│  │  volatile)│    │  Node:thread  │  │
│  └──────────┘    │  + waitStatus │  │
│                   └───────────────┘  │
│                                      │
│  tryAcquire() / tryRelease()  ← 子类实现  │
│  tryAcquireShared() / tryReleaseShared() │
└─────────────────────────────────────┘

// AQS 内部就是一个 volatile int
private volatile int state;

// 提供三个方法操作（都是 CAS 原子操作）
protected final int getState() { return state; }
protected final void setState(int newState) { state = newNode; }
protected final boolean compareAndSetState(int expect, int update) {
    // 底层调用 Unsafe.compareAndSwapInt
}

static final class Node {
    volatile Node prev;       // 前驱节点
    volatile Node next;       // 后继节点
    volatile Thread thread;   // 等待的线程
    int waitStatus;           // 等待状态
    // waitStatus 取值：
    //   0: 初始状态
    //   SIGNAL(-1): 后继节点需要被唤醒
    //   CANCELLED(1): 节点已取消
    //   CONDITION(-2): 节点在 Condition 队列中
    //   PROPAGATE(-3): 共享模式下传播释放信号
}

acquire(arg)
  │
  ├─ tryAcquire(arg) ──成功──▶ 直接返回（无需入队）
  │                  ──失败──▶ addWaiter(Node.EXCLUSIVE)  // 尾插法加入队列
  │                               │
  │                               ▼
  │                        acquireQueued(node, arg)
  │                          │
  │                          ├─ 前驱是 head → 再 tryAcquire 一次（抢锁机会）
  │                          │     └─ 成功 → 设置自己为 head，返回
  │                          │     └─ 失败 → shouldParkAfterFailedAcquire()
  │                          │              └─ 检查前驱 waitStatus
  │                          │                 └─ SIGNAL → park（挂起，等待 unpark）
  │                          │                 ── CANCELLED → 跳过前驱，重试
  │                          │
  │                          └─ 被唤醒后 → 再次循环 tryAcquire
  │
  └─ 如果中断 → selfInterrupt() 补上中断标记

// NonfairSync —— 非公平锁
static final class NonfairSync extends Sync {
    final void lock() {
        if (compareAndSetState(0, 1))  // 先直接 CAS 抢锁！
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);  // 抢不到再走 AQS 流程
    }

    protected final boolean tryAcquire(int acquires) {
        // 非公平：不管队列里有没有等待的线程，直接抢
        ...
    }
}

// FairSync —— 公平锁
static final class FairSync extends Sync {
    protected final boolean tryAcquire(int acquires) {
        // 公平：检查是否有前驱节点，有则放弃抢锁
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (!hasQueuedPredecessors() &&   // ★ 关键：看队列里有没有人
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        ...
    }
}

// 简化的可重入逻辑
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) { ... return true; }
    }
    else if (current == getExclusiveOwnerThread()) {  // 已经是持有者 → 重入
        int nextc = c + acquires;
        if (nextc < 0) throw new Error("Maximum lock count exceeded");
        setState(nextc);  // 直接设置 state，无需 CAS（因为只有持有者才能到这里）
        return true;
    }
    return false;
}

ReentrantLock lock = new ReentrantLock();
Condition notFull = lock.newCondition();   // 队列不满条件
Condition notEmpty = lock.newCondition();  // 队列不空条件

// 生产者
lock.lock();
try {
    while (count == bufferSize) notFull.await();  // 队列满 → 等待
    enqueue(item);
    notEmpty.signal();                            // 通知消费者
} finally { lock.unlock(); }

// 消费者
lock.lock();
try {
    while (count == 0) notEmpty.await();  // 队列空 → 等待
    item = dequeue();
    notFull.signal();                        // 通知生产者
} finally { lock.unlock(); }

// 场景：主线程等待 N 个子线程全部完成后汇总
CountDownLatch latch = new CountDownLatch(3);  // 初始计数 = 3

for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        try {
            // 执行任务...
        } finally {
            latch.countDown();  // 计数 -1
        }
    }).start();
}

latch.await();  // 阻塞等待，直到计数归零
System.out.println("所有任务完成！");

// 场景：限流 —— 控制同时访问某资源的线程数不超过 N
Semaphore semaphore = new Semaphore(5);  // 5 个许可

for (int i = 0; i < 20; i++) {
    new Thread(() -> {
        try {
            semaphore.acquire();   // 获取许可（阻塞式）
            // 访问受限资源...
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release();  // 归还许可
        }
    }).start();
}

// 场景：N 个线程互相等待，全部到达后一起继续（可重复使用）
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("所有选手到达终点，开始颁奖！");
});

for (int i = 0; i < 3; i++) {
    final int no = i + 1;
    new Thread(() -> {
        System.out.println("选手 " + no + " 出发...");
        try {
            Thread.sleep((long)(Math.random() * 3000));
            System.out.println("选手 " + no + " 到达终点");
            barrier.await();  // 等待其他线程
            System.out.println("选手 " + no + " 继续下一轮比赛");
        } catch (Exception e) { e.printStackTrace(); }
    }).start();
}

// put 操作简化流程
final V putVal(K key, V value, boolean onlyIfAbsent) {
    // ... hash 计算 ...

    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();                    // ① 表空 → 初始化
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node(...)))  // ② 桶空 → CAS 插入
                break;                                   //    无锁成功
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);              // ③ 正在扩容 → 协助迁移
        else {
            synchronized (f) {                       // ④ 桶非空 → 加锁（锁住头节点）
                // 链表遍历 or 红黑树操作...
            }
        }
    }
    // ... addCount() → 可能触发扩容 ...
}

// 写时复制列表 —— 读完全无锁，写时复制整个底层数组
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

// 读操作：直接读数组，无锁（适合读多写少）
String s = list.get(0);

// 写操作：复制新数组，修改后替换引用
list.add("hello");  // 内部：Arrays.copyOf() → 新数组添加 → 替换

// 生产者-消费者经典模式
BlockingQueue<Task> queue = new ArrayBlockingQueue<>(128);

// 生产者
queue.put(task);     // 队列满时阻塞

// 消费者
Task task = queue.take();  // 队列空时阻塞

需要 Map？
  ├── 读多写少 → ConcurrentHashMap（首选）
  ├── 要求强一致 → Collections.synchronizedMap()（性能差但简单）
  └── 需要排序 → ConcurrentSkipListMap（跳表，有序）

需要 List？
  ├── 读多写少 → CopyOnWriteArrayList
  └── 读写均衡 → Collections.synchronizedList() 或手动加锁

需要 Queue？
  ├── 有界队列 → ArrayBlockingQueue
  ├── 无界队列 → LinkedBlockingQueue
  ├── 直接传递 → SynchronousQueue
  └── 延迟任务 → DelayQueue

JMM（可见性/原子性/有序性）
  ↓
volatile（内存屏障 + MESI）←→ synchronized（锁升级：偏向→轻量→重量）
  ↓
CAS（CPU 原子指令）+ ABA 问题
  ↓
Atomic 原子类（基于 CAS + 自旋）
  ↓
AQS 框架（state + CLH 队列 + 独占/共享模式）
  ↓
  ├── ReentrantLock（可重入 + 公平/非公平 + Condition）
  ├── CountDownLatch（一次性倒计时）
  ├── Semaphore（信号量限流）
  └── CyclicBarrier（循环栅栏）
  ↓
并发容器（ConcurrentHashMap / CopyOnWriteArrayList / BlockingQueue）