Java中可重入锁介绍、应用场景和示例代码

可重入锁（Reentrant Lock） 是一种特殊的锁机制，在 Java 中主要由 ReentrantLock 类提供。它的最大特点是：同一个线程可以多次获得同一个锁，而不会发生死锁现象。当线程持有该锁时，它可以多次进入并获得该锁，每次进入时需要调用 lock() 方法，相应的 unlock() 也需要被调用相同次数以释放锁。

1. 概念：

• 可重入性：即同一个线程在没有释放锁的情况下，可以多次获得该锁，而不会发生阻塞。
• 非可重入锁：线程如果没有释放锁，尝试再次获取同一把锁时会阻塞自己，直到锁被释放。

2. 为什么需要可重入锁：

通常，某个线程可能在持有锁的情况下再次调用需要该锁的代码。例如，线程在方法 A 中获取锁后，调用方法 B，而方法 B 内部也有加锁逻辑。没有可重入性的话，线程会因为无法再次获得锁而陷入死锁或被阻塞。

3. ReentrantLock 与 synchronized 的对比

• ReentrantLock 是 java.util.concurrent.locks 包下的类，提供了更细粒度的控制，比如尝试加锁、超时加锁等。
• synchronized 是 Java 内建的关键字，用于同步方法或代码块，它提供的是隐式的锁机制。

相同点：

• 两者都提供了互斥锁的功能，保证同一时刻只有一个线程能够执行被锁保护的代码块。

区别：

• ReentrantLock 可以在同一线程中多次获取锁，而 synchronized 是隐式的，通常只有一次。
• ReentrantLock 提供了更多的控制方法，如 tryLock(), lockInterruptibly() 等，而 synchronized 只有进入和退出时隐式获取锁。
• ReentrantLock 需要手动释放锁，而 synchronized 会自动释放锁（当方法/代码块执行完毕后）。

---

ReentrantLock 的常用方法

• lock(): 获取锁，如果锁被其他线程占用，当前线程会阻塞直到获得锁。
• unlock(): 释放锁，当前线程必须在获取锁后调用此方法释放锁。
• tryLock(): 尝试获取锁。如果锁没有被其他线程占用，则获取锁并返回 true，如果锁已被占用，则返回 false，不会阻塞当前线程。
• tryLock(long time, TimeUnit unit): 尝试在指定的时间内获取锁，如果在时间内获得锁，则返回 true，否则返回 false。
• lockInterruptibly(): 获取锁，如果锁被占用，线程会被阻塞，直到当前线程被中断或获得锁。
• isLocked(): 检查锁是否被任何线程持有。
• getHoldCount(): 返回当前线程持有锁的次数。

---

可重入锁应用场景

1. 避免死锁：

   • 如果某个线程需要执行一段代码，该段代码内有递归调用，而递归调用的代码也需要获取锁，此时就需要可重入锁来防止死锁。

2. 嵌套方法调用：

   • 当方法 A 获取锁后，调用方法 B，而方法 B 内部又有加锁逻辑，使用可重入锁可以保证方法 B 中的代码不会阻塞。

3. 需要线程中断的场景：

   • ReentrantLock 提供了 lockInterruptibly() 方法，允许线程在等待锁的过程中能够响应中断。

4. 尝试加锁：

   • 使用 tryLock() 方法可以避免线程在等待锁时被阻塞，适用于不希望线程长期等待锁的场景。

---

可重入锁的示例代码

下面是一个简单的示例，演示了如何使用 ReentrantLock 实现可重入锁的功能：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {

    private final Lock lock = new ReentrantLock();

    // Method A - 外部方法
    public void methodA() {
        lock.lock();  // 获取锁
        try {
            System.out.println("Method A: Acquired lock in method A");
            methodB();  // 内部调用 methodB
        } finally {
            lock.unlock();  // 释放锁
        }
    }

    // Method B - 内部方法
    public void methodB() {
        lock.lock();  // 获取锁
        try {
            System.out.println("Method B: Acquired lock in method B");
            // Perform some operations in method B
        } finally {
            lock.unlock();  // 释放锁
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        example.methodA();  // 调用 methodA，methodB 内部也会尝试获取锁
    }
}

输出

Method A: Acquired lock in method A
Method B: Acquired lock in method B

在这个例子中：

• methodA() 获取锁后，调用了 methodB()。由于锁是可重入的，methodB() 也能够成功获取锁，而不会因为线程已经持有锁而阻塞。

---

tryLock 示例

tryLock() 方法允许你尝试获取锁，如果锁被占用，则返回 false，而不会阻塞当前线程。适用于你希望避免线程被长时间阻塞的情况。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TryLockExample {

    private final Lock lock = new ReentrantLock();

    public void tryLockExample() {
        if (lock.tryLock()) {
            try {
                System.out.println(Thread.currentThread().getName() + " acquired lock.");
                // Simulate some work
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println(Thread.currentThread().getName() + " could not acquire lock.");
        }
    }

    public static void main(String[] args) {
        TryLockExample example = new TryLockExample();

        // Start two threads to simulate tryLock
        Thread t1 = new Thread(example::tryLockExample);
        Thread t2 = new Thread(example::tryLockExample);

        t1.start();
        t2.start();
    }
}

输出示例

Thread-0 acquired lock.
Thread-1 could not acquire lock.

在这个例子中：

• Thread-0 成功获得锁并执行，Thread-1 尝试获取锁失败，因为锁已经被 Thread-0 持有。

---

总结

• 可重入锁（ReentrantLock）是 Java 中的一种常用锁，允许同一个线程多次获取锁，避免了死锁和阻塞问题。
• ReentrantLock 提供了更灵活的锁操作，如 tryLock()、lockInterruptibly() 等，适合一些需要高级控制的场景。
• 适用场景包括：嵌套方法调用、避免死锁、线程中断处理、尝试加锁等。
• 使用 ReentrantLock 时，务必注意释放锁，以避免死锁。