Java 并发编程（七）：重入锁 ReentrantLock

亦凉 2022-05-12 09:18 281阅读 0赞

### 文章目录 ###

*   *   *  1、ReentrantLock 重入锁简介
         *  2、ReentrantLock 如何实现锁重入
         *  3、 ReentrantLock 如何实现锁的公平性与非公平性

### 1、ReentrantLock 重入锁简介 ###

重入锁 ReentrantLock，顾名思义，就是支持同一个线程对资源的重复加锁。另外，该锁还支持获取锁时的公平与非公平性的选择。

重入锁 ReentrantLock，只支持独占方式的获取操作，因此它只实现了 tryAcquire、tryRelease 和 isHeldExclusively 方法。

### 2、ReentrantLock 如何实现锁重入 ###

锁重入是指任意线程在获取到锁之后，能够再次获取该锁而不会被锁所阻塞，该特性的实现需要解决两个问题：

**1、线程再次获取锁**

需要识别获取锁的线程是否为当期占有锁的线程，如果是，则便获取锁成功

**2、锁最终得到释放**

同一个线程重复 n 次获得了锁，在第 n 次释放该锁后，其它线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时，表示锁已经成功释放

--------------------

ReentrantLock 是通过自定义同步器来实现所得获取和释放，默认使用非公平性，下面就以非公平性获取锁为例，学习重入锁是如何实现的：

final boolean nonfairTryAcquire(int acquires) {
                //当前线程
                final Thread current = Thread.currentThread();
                //当前同步状态
                int c = getState();
                //当前同步状态等于0，说明当前线程可以获取同步状态
                if (c == 0) {
                    if (compareAndSetState(0, acquires)) {
                    //设置锁的拥有这位当前线程
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) {
                //当前线程拥有锁并且再次请求，同步状态的值增加
                    int nextc = c + acquires;
                    if (nextc < 0) // overflow
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }

通过判断当前线程是否为获取锁的线程来决定获取操作是否成功，如果是获取锁的线程，则将同步状态值进行累加并返回true，表示获取同步状态成功。

成功获取锁的线程再次获取锁，只是增加了同步状态值，这也就要求在释放同步状态时递减同步状态的值。如下，释放锁的代码：

protected final boolean tryRelease(int releases) {
                int c = getState() - releases;
                if (Thread.currentThread() != getExclusiveOwnerThread())
                    throw new IllegalMonitorStateException();
                boolean free = false;
                if (c == 0) {
                    free = true;
                    setExclusiveOwnerThread(null);
                }
                setState(c);
                return free;
            }

如果该锁被获取了n次， 那么前( n- 1) 次 tryRelease( int releases) 方法必须返回false，只有同步状态完全释放了，才能返回tru。 该方法将同步状态 是否为 0 作为作为最终释放的条件，当同步状态为0时，将该锁的拥有者线程设置为null，并返回true，表示成功释放。

### 3、 ReentrantLock 如何实现锁的公平性与非公平性 ###

公平性与否是针对获取锁而言的，如果一个锁时公平的，那么锁的获取顺序就应该服务请求时间的顺序，也就是FIFO。

由上文介绍的非公平获取锁方法 nonfairTryAcquire( int acquires) 可知，只要CAS设置同步状态成功，则表示线程获取了锁，而公平锁则不同，如代码所示：

static final class FairSync extends Sync {
    
    protected final boolean tryAcquire(int acquires) {
                final Thread current = Thread.currentThread();
                int c = getState();
                if (c == 0) {
                    if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) {
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                else if (current == getExclusiveOwnerThread()) {
                    int nextc = c + acquires;
                    if (nextc < 0)
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }
    }

该方法与 nonfairTryAcquire( int acquires) 的区别在于多了hasQueuedPredecessors() 方法，即加入了同步队列中当前节点是否有前驱节点的判断，如果该方法返回true，则表示有线程比当前线程更早的请求了锁，因此需要等待前驱线程获取并释放锁之后才能继续获取锁。