java 不可重入锁

原创

mob649e8166c3a5 2023-08-22 10:40:50 ©著作权

©著作权归作者所有：来自51CTO博客作者mob649e8166c3a5的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 不可重入锁

在并发编程中，锁是一种常用的同步机制，用于保护共享资源的访问。Java提供了synchronized关键字和Lock接口来支持锁的使用。大多数情况下，我们使用的锁都是可重入的，即同一个线程可以多次获得同一个锁。但是，在某些情况下，我们可能需要使用不可重入锁。本文将介绍什么是不可重入锁，以及如何在Java中使用它。

什么是不可重入锁？

不可重入锁是一种特殊的锁，它不允许同一个线程在持有锁的情况下再次获得锁。如果一个线程已经持有了锁，并且再次尝试获得该锁，那么该线程将被阻塞，直到其他线程释放了锁。不可重入锁可以防止线程进入死锁的状态。

不可重入锁的实现

在Java中，我们可以通过继承java.util.concurrent.locks.ReentrantLock类，并重写lock和unlock方法来实现一个不可重入锁。下面是一个简单的示例：

import java.util.concurrent.locks.ReentrantLock;

public class NonReentrantLock extends ReentrantLock {
    private Thread lockedBy = null;

    @Override
    public synchronized void lock() {
        if (isLocked() && lockedBy != Thread.currentThread()) {
            throw new IllegalMonitorStateException("Lock already held by another thread");
        }
        super.lock();
        lockedBy = Thread.currentThread();
    }

    @Override
    public synchronized void unlock() {
        if (lockedBy == Thread.currentThread()) {
            super.unlock();
            lockedBy = null;
        }
    }
}

在上面的代码中，我们继承了ReentrantLock类，并重写了lock和unlock方法。在lock方法中，我们首先判断锁是否已经被持有，并且持有锁的线程是否为当前线程。如果是，则抛出IllegalMonitorStateException异常，表示锁已经被另一个线程持有。否则，调用父类的lock方法来获取锁，并将持有锁的线程设置为当前线程。在unlock方法中，我们只有当持有锁的线程为当前线程时，才释放锁，并将持有锁的线程设置为null。

使用不可重入锁

使用不可重入锁与使用可重入锁的方式类似。下面是一个使用不可重入锁的示例：

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

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

    public static void main(String[] args) {
        new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Thread 1 acquired the lock");
                // 在持有锁的情况下，再次尝试获取锁
                lock.lock(); // 该行代码将会导致线程阻塞
                System.out.println("Thread 1 re-acquired the lock");
            } finally {
                lock.unlock();
            }
        }).start();

        new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Thread 2 acquired the lock");
            } finally {
                lock.unlock();
            }
        }).start();
    }
}

在上面的代码中，我们创建了一个不可重入锁实例lock。然后，我们创建了两个线程，分别尝试获得锁。线程1在获得锁之后，再次尝试获取锁，这将导致线程阻塞。而线程2在获得锁之后，并没有再次尝试获取锁。