发编程：可重入锁、不可重入锁、公平锁、非公平锁

并发编程：可重入锁、不可重入锁、公平锁、非公平锁

一、可重入锁（Reentrant Lock）

✅ 概念

同一个线程在外层方法获取锁之后，在进入该锁保护的内层方法时，可以再次获得锁，不会被自己阻塞。

📌 特点：

• 锁维护一个持有线程的引用和重入计数器
• 每 lock() 一次，计数 +1，unlock() 一次，计数 -1

💻 Java 示例

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

    public void outer() {
        lock.lock();
        try {
            System.out.println("Entered outer");
            inner(); // 可重入：这里不会死锁
        } finally {
            lock.unlock();
        }
    }

    public void inner() {
        lock.lock(); // 同一线程再次获得锁
        try {
            System.out.println("Entered inner");
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        new ReentrantExample().outer();
    }
}

🧠 本质：

JDK 提供的 synchronized 和 ReentrantLock 默认就是可重入锁。

二、不可重入锁（Non-Reentrant Lock）

❌ 概念

一个线程再次请求自己持有的锁时会被阻塞，容易导致死锁。

🧪 示例（自定义一个不可重入锁）：

public class NonReentrantLock {
    private boolean isLocked = false;
    private Thread lockedBy = null;

    public synchronized void lock() throws InterruptedException {
        while (isLocked) {
            wait();
        }
        isLocked = true;
        lockedBy = Thread.currentThread();
    }

    public synchronized void unlock() {
        if (Thread.currentThread() == lockedBy) {
            isLocked = false;
            lockedBy = null;
            notify();
        }
    }
}

📌 风险：

public class Test {
    private final NonReentrantLock lock = new NonReentrantLock();

    public void methodA() throws InterruptedException {
        lock.lock();
        System.out.println("methodA");
        methodB(); // 死锁：同线程再次加锁会阻塞
        lock.unlock();
    }

    public void methodB() throws InterruptedException {
        lock.lock(); // 被阻塞
        System.out.println("methodB");
        lock.unlock();
    }
}

三、公平锁（Fair Lock）

✅ 概念

线程获取锁的顺序与它们请求锁的顺序一致，先来先得。

🔍 Java 实现

ReentrantLock lock = new ReentrantLock(true); // 公平锁

📌 特点

• 所有等待线程会排队
• 每个线程轮到时才能拿到锁
• 避免线程饥饿

四、非公平锁（Non-Fair Lock）

❌ 概念

线程在请求锁时，可以插队，如果锁空闲就立即获取，不管有没有其他等待线程。

🔍 Java 实现

ReentrantLock lock = new ReentrantLock(false); // 非公平锁，默认

📌 特点

• 性能高，吞吐量大
• 可能出现饥饿现象
• 减少线程上下文切换

五、总结

六、建议使用方式