ReentrantLock(可重入锁)的应用、核心原理及实战

package com.demo;

import java.util.concurrent.locks.ReentrantLock;

public class T7 {
    private final ReentrantLock lock = new ReentrantLock();

    public void outerMethod() {
        lock.lock();
        try {
            System.out.println("Outer method is running.");
            innerMethod();
        } finally {
            lock.unlock();
        }
    }

    public void innerMethod() {
        lock.lock();
        try {
            System.out.println("Inner method is running.");
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        T7 demo = new T7();

        // 同一个线程调用 outerMethod 和 innerMethod
        demo.outerMethod();
    }
}

final boolean nonfairTryAcquire(int acquires) {
    // 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取当前锁的状态（state），state 表示当前锁的持有次数
    int c = getState();
    
    // 如果当前锁的状态为 0，表示锁未被任何线程持有
    if (c == 0) {
        // 使用 CAS 操作尝试将锁的状态从 0 设置为 acquires（通常是 1）
        if (compareAndSetState(0, acquires)) {
            // 如果 CAS 成功，设置当前线程为锁的持有者
            setExclusiveOwnerThread(current);
            // 返回 true 表示获取锁成功
            return true;
        }
    }
    // 如果当前锁已被持有，并且持有者是当前线程（可重入锁的特性）
    else if (current == getExclusiveOwnerThread()) {
        // 计算新的锁状态值（当前状态 + acquires）
        int nextc = c + acquires;
        // 检查是否发生溢出（锁的最大持有次数超过 Integer.MAX_VALUE）
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 更新锁的状态为新的值
        setState(nextc);
        // 返回 true 表示获取锁成功
        return true;
    }
    // 如果当前线程无法获取锁（锁被其他线程持有，且当前线程不是持有者）
    return false;
}