public interface Lock {
    void lock();                // 获取锁（阻塞，直到获取成功）
    void lockInterruptibly();   // 可中断地获取锁（阻塞时可以被中断）
    boolean tryLock();          // 尝试获取锁（立即返回，成功 true / 失败 false）
    boolean tryLock(long time, TimeUnit unit); // 带超时的尝试获取
    void unlock();              // 释放锁
    Condition newCondition();   // 创建条件队列
}

lock.lock();
try {
    // 临界区代码
} finally {
    lock.unlock(); // 保证锁一定能释放
}

public void outer() {
    lock.lock();
    try {
        inner(); // 同一个线程可以再次获取锁
    } finally {
        lock.unlock();
    }
}

public void inner() {
    lock.lock();
    try {
        // 即使 outer 已持锁，这里也能获取成功（可重入）
    } finally {
        lock.unlock();
    }
}

// 非公平锁（默认）：线程先抢锁，抢不到才排队
ReentrantLock unfairLock = new ReentrantLock(false);

// 公平锁：FIFO 排队，先来的先得
ReentrantLock fairLock = new ReentrantLock(true);

public class CacheService {
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final Lock readLock = rwLock.readLock();
    private final Lock writeLock = rwLock.writeLock();
    private final Map<String, Object> cache = new HashMap<>();

    // 读 — 多个线程并发读
    public Object get(String key) {
        readLock.lock();
        try {
            return cache.get(key);
        } finally {
            readLock.unlock();
        }
    }

    // 写 — 独占
    public void put(String key, Object value) {
        writeLock.lock();
        try {
            cache.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }

    // 锁降级：写 → 读（保证写完后能继续读）
    public void updateAndRead(String key, Object value) {
        writeLock.lock();
        try {
            cache.put(key, value);
            readLock.lock(); // 写锁持有中，获取读锁成功（锁降级）
        } finally {
            writeLock.unlock(); // 释放写锁，降级为读锁状态
        }
        try {
            Object val = cache.get(key); // 此时仍持有读锁，数据安全
        } finally {
            readLock.unlock();
        }
    }
}

public class PointService {
    private final StampedLock stampedLock = new StampedLock();
    private int x = 0, y = 0;

    // 写操作 — 独占
    public void move(int dx, int dy) {
        long stamp = stampedLock.writeLock();
        try {
            x += dx;
            y += dy;
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }

    // 乐观读 — 不加锁，性能极高
    public int readOptimistic() {
        // ① 乐观读：拿到 stamp 戳
        long stamp = stampedLock.tryOptimisticRead();
        int curX = x, curY = y;

        // ② 验证：数据有没有被写线程修改过？
        if (!stampedLock.validate(stamp)) {
            // ③ 被修改了，升级为悲观读锁
            stamp = stampedLock.readLock();
            try {
                curX = x;
                curY = y;
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
        return curX + curY;
    }
}

public class BoundedQueue<T> {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull  = lock.newCondition();  // 不满条件
    private final Condition notEmpty = lock.newCondition();  // 不空条件
    private final Queue<T> queue = new LinkedList<>();
    private final int capacity;

    public BoundedQueue(int capacity) {
        this.capacity = capacity;
    }

    // 生产者：队列满则等待「不满」信号
    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                notFull.await();    // 队列满了，等待不满条件
            }
            queue.offer(item);
            notEmpty.signal();      // 通知消费者：队列不空了
        } finally {
            lock.unlock();
        }
    }

    // 消费者：队列空则等待「不空」信号
    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();   // 队列空了，等待不空条件
            }
            T item = queue.poll();
            notFull.signal();       // 通知生产者：队列不满了
            return item;
        } finally {
            lock.unlock();
        }
    }
}

// await() 必须在循环中检查条件（防止假唤醒）
while (条件不满足) {
    condition.await(); // 不是 if，是 while！
}

// signal() 必须在条件满足时调用
if (条件满足) {
    condition.signal(); // 或 signalAll()
}

LockSupport.park();            // 阻塞当前线程
LockSupport.parkNanos(long nanos);   // 超时阻塞
LockSupport.unpark(Thread t);  // 唤醒指定线程

// 精准唤醒（对比 notify 的随机唤醒优势明显）
Thread worker = new Thread(() -> {
    System.out.println("等待任务...");
    LockSupport.park();
    System.out.println("被唤醒了！");
});
worker.start();

Thread.sleep(1000);
LockSupport.unpark(worker); // 精准唤醒 worker 线程

// 模式一：lock + try-finally（最常用）
lock.lock();
try {
    // 业务逻辑
} finally {
    lock.unlock();
}

// 模式二：tryLock + 双检查
if (lock.tryLock()) {
    try {
        // 业务逻辑
    } finally {
        lock.unlock();
    }
} else {
    // 获取失败的处理
}

// 模式三：lockInterruptibly
lock.lockInterruptibly();
try {
    // 业务逻辑（可被中断取消）
} finally {
    lock.unlock();
}

// === 非公平锁 ===
final void lock() {
    // 一进来就 CAS 抢一次，不管队列里有没有人在等
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1); // 抢不到才走排队流程
}

// === 公平锁 ===
protected final boolean tryAcquire(int acquires) {
    // 先检查队列中是否有前驱在等待
    if (!hasQueuedPredecessors() &&     // 唯一区别！
        compareAndSetState(0, acquires)) {
        setExclusiveOwnerThread(current);
        return true;
    }
}