Java中怎么实现不可重入锁和可重入锁

在Java中，锁是控制多个线程对共享资源访问的重要机制。锁可以分为不可重入锁和可重入锁。本文将详细介绍这两种锁的概念，并通过代码示例展示如何在Java中实现它们。

1. 不可重入锁

不可重入锁（Non-Reentrant Lock）是指同一个线程在持有锁的情况下，再次尝试获取该锁时会被阻塞。这种锁的实现相对简单，但可能会导致死锁问题。

1.1 实现不可重入锁

我们可以通过一个简单的布尔变量来实现不可重入锁。以下是一个不可重入锁的实现示例：

public class NonReentrantLock {
    private boolean isLocked = false;

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

    public synchronized void unlock() {
        isLocked = false;
        notify();
    }
}

1.2 使用不可重入锁

以下是一个使用不可重入锁的示例：

public class NonReentrantLockExample {
    private NonReentrantLock lock = new NonReentrantLock();

    public void outer() throws InterruptedException {
        lock.lock();
        try {
            inner();
        } finally {
            lock.unlock();
        }
    }

    public void inner() throws InterruptedException {
        lock.lock();
        try {
            // 临界区代码
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        NonReentrantLockExample example = new NonReentrantLockExample();
        try {
            example.outer();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，outer方法调用了inner方法，但由于使用的是不可重入锁，inner方法在尝试获取锁时会被阻塞，导致死锁。

2. 可重入锁

可重入锁（Reentrant Lock）是指同一个线程在持有锁的情况下，可以多次获取该锁而不会被阻塞。Java中的ReentrantLock类就是一个典型的可重入锁实现。

2.1 实现可重入锁

我们可以通过记录持有锁的线程和重入次数来实现可重入锁。以下是一个简单的可重入锁实现示例：

public class ReentrantLock {
    private Thread lockedBy = null;
    private int lockCount = 0;

    public synchronized void lock() throws InterruptedException {
        Thread callingThread = Thread.currentThread();
        while (lockedBy != null && lockedBy != callingThread) {
            wait();
        }
        lockedBy = callingThread;
        lockCount++;
    }

    public synchronized void unlock() {
        if (Thread.currentThread() == lockedBy) {
            lockCount--;
            if (lockCount == 0) {
                lockedBy = null;
                notify();
            }
        }
    }
}

2.2 使用可重入锁

以下是一个使用可重入锁的示例：

public class ReentrantLockExample {
    private ReentrantLock lock = new ReentrantLock();

    public void outer() throws InterruptedException {
        lock.lock();
        try {
            inner();
        } finally {
            lock.unlock();
        }
    }

    public void inner() throws InterruptedException {
        lock.lock();
        try {
            // 临界区代码
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantLockExample example = new ReentrantLockExample();
        try {
            example.outer();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，outer方法调用了inner方法，由于使用的是可重入锁，inner方法可以成功获取锁，不会导致死锁。

3. Java中的ReentrantLock类

Java标准库中提供了ReentrantLock类，它是一个功能强大的可重入锁实现。ReentrantLock类提供了比synchronized关键字更灵活的锁操作，例如尝试获取锁、超时获取锁、可中断获取锁等。

3.1 使用ReentrantLock

以下是一个使用ReentrantLock的示例：

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

public class ReentrantLockExample {
    private Lock lock = new ReentrantLock();

    public void outer() {
        lock.lock();
        try {
            inner();
        } finally {
            lock.unlock();
        }
    }

    public void inner() {
        lock.lock();
        try {
            // 临界区代码
        } finally {
            lock.unlock();
        }
    }

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

在这个示例中，ReentrantLock的使用方式与自定义的可重入锁类似，但ReentrantLock提供了更多的功能和更好的性能。

4. 总结

不可重入锁和可重入锁是Java中两种常见的锁机制。不可重入锁实现简单，但可能会导致死锁问题；可重入锁则更加灵活和安全，适用于复杂的多线程场景。Java标准库中的ReentrantLock类是一个功能强大的可重入锁实现，推荐在实际开发中使用。

通过本文的介绍和示例代码，相信读者已经对Java中的不可重入锁和可重入锁有了更深入的理解。在实际开发中，选择合适的锁机制可以有效提高程序的并发性能和稳定性。