十一. 重入锁-ReentrantLock原理分析

待我称王封你为后i 2024-03-29 15:08 55阅读 0赞

### 前言 ###

重入锁，即`ReentrantLock`，继承于`Lock`接口，提供锁重入功能。重入锁与不可重入锁的区别在于，重入锁支持已经获取锁的线程重复对锁资源进行获取。

### 正文 ###

`Java`中的`synchronized`关键字可以隐式的支持锁重入功能，考虑如下一个例子。

public class HelloUtil {
        
    
        public static synchronized void sayHello() {
        
            System.out.print("Hello ");
            sayWorld();
        }
    
        public static synchronized void sayWorld() {
        
            System.out.println("World");
        }
    
    }

已知访问由`synchronized`关键字修饰的静态方法时需要先获取方法所在类的`Class`对象作为锁资源，所以当**A**线程调用`HelloUtil`的`sayHello()`方法时，需要获取的锁资源为`HelloUtil`类的`Class`对象，此时**B**线程再调用`HelloUtil`的`sayHello()`或`sayWorld()`方法时会被阻塞，但是**A**线程却可以在`sayHello()`方法中再调用`sayWorld()`方法，即**A**线程在已经获取了锁资源的情况下又获取了一次锁资源，这就是`synchronized`关键字对锁重入的支持。

结合上面的例子，已经对重入锁有了直观的认识，下面将分析`ReentrantLock`是如何实现重入锁的。`ReentrantLock`的类图如下所示。

![在这里插入图片描述][c9c9cf3921fe4b0e9d00ded5a0218477.jpeg_pic_center]

`ReentrantLock`有三个静态内部类，其中`Sync`继承于`AbstractQueuedSynchronizer`，然后`FairSync`和`NonfairSync`继承于`Sync`，因此`Sync`，`FairSync`和`NonfairSync`均是`ReentrantLock`组件中的自定义同步器，且`FairSync`提供公平获取锁机制，`NonfairSync`提供非公平获取锁机制。公平和非公平获取锁机制现在暂且不谈，下面先看一下`Sync`，`FairSync`和`NonfairSync`实现了哪些方法，如下所示。

![在这里插入图片描述][6bf8d2e37e37467294551a182c098373.jpeg_pic_center]

由上述可知，`ReentrantLock`默认使用非公平获取锁机制，然后可以在构造函数中根据传入的**fair**参数决定使用哪种机制。现在先对上面的讨论做一个小节：**`ReentrantLock`是可重入锁，即已经获取锁资源的线程可以重复对锁资源进行获取，`ReentrantLock`内部有三个自定义同步器，分别为`Sync`，`NonfairSync`和`FairSync`，其中`NonfairSync`和`FairSync`能分别提供非公平获取锁机制和公平获取锁机制，具体使用哪一种获取锁机制，需要在`ReentrantLock`的构造函数中指定。**

接下来结合`NonfairSync`和`FairSync`的`lock()`和`tryAcquire()`方法的源码，对非公平获取锁机制和公平获取锁机制进行说明。

`NonfairSync`的`lock()`方法如下所示。

final void lock() {
        
    	if (compareAndSetState(0, 1))
    		setExclusiveOwnerThread(Thread.currentThread());
    	else
    		acquire(1);
    }

非公平获取锁调用`lock()`方法时会先将**state**以**CAS**方式从0设置为1，设置成功表示竞争到了锁，**因此非公平获取锁意味着同时获取锁资源时会存在竞争关系，不能满足先到先获取的原则**。如果将**state**以**CAS**方式从0设置为1失败时，会调用模板方法`acquire()`，已知`acquire()`方法会调用`tryAcquire()`方法，而`NonfairSync`的`tryAcquire()`方法会调用其父类`Sync`的`nonfairTryAcquire()`方法，下面看一下其实现。

final boolean nonfairTryAcquire(int acquires) {
        
    	final Thread current = Thread.currentThread();
    	int c = getState();
    	if (c == 0) {
        
    		if (compareAndSetState(0, acquires)) {
        
    			setExclusiveOwnerThread(current);
    			return true;
    		}
    	}
    	// 当前线程如果是获取到锁资源的线程，则将state字段加1
    	// 当前线程如果不是获取到锁资源的线程，则返回false然后加入同步队列
    	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()`方法中主要是对获取锁资源的线程进行判断，如果当前线程就是已经获取到锁资源的线程，那么就会将**state**加1，因为每次都是将**state**加1，所以可以重复获取锁资源。

接下来再看一下公平获取锁机制的`FairSync`的实现，首先`FairSync`的`lock()`方法会直接调用模板方法`acquire()`，并已知在`acquire()`方法中会调用`tryAcquire()`方法，所以这里直接看`FairSync`的`tryAcquire()`方法的实现。

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;
    }

`FairSync`的`tryAcquire()`方法与`NonfairSync`的不同在于当**state**为0时多了一个`hasQueuedPredecessors()`方法的判断逻辑，即判断当前的同步队列中是否已经有正在等待获取锁资源的线程，如果有，则返回**true**，**因此公平获取锁意味着绝对时间上最先请求锁资源的线程会最先获取锁，以及等待获取锁资源时间最长的线程会最优先获取锁，这样的获取锁机制就是公平的。**

现在最后分析一下`ReentrantLock`的解锁逻辑。无论是非公平获取锁机制还是公平获取锁机制，如果重复对锁资源进行了**n**次获取，那么成功解锁就需要对锁资源进行**n**次释放，前`(n - 1)`次释放锁资源都应该返回**false**。`ReentrantLock`的`unlock()`方法会直接调用`AbstractQueuedSynchronizer`的模板方法`release()`，并已知在`release()`方法中会调用`tryRelease()`方法，这里调用的是`Sync`实现的`tryRelease()`方法，如下所示。

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;
    }

`tryRelease()`方法中每成功释放一次锁资源，就会将**state**减1，所以当**state**为0时，就判断锁资源被全部释放，即释放锁资源成功。

### 总结 ###

重入锁的定义是：**已经获取锁资源的线程可以重复对锁资源进行获取**。

`ReentrantLock`是重入锁，内部有三个自定义同步器，分别为`Sync`，`NonfairSync`和`FairSync`，其中`NonfairSync`和`FairSync`能分别提供非公平获取锁机制和公平获取锁机制，具体使用哪一种获取锁机制，需要在`ReentrantLock`的构造函数中指定。

非公平锁的定义是：**同时获取锁资源时会存在竞争关系，不能满足先到先获取的原则**。

公平锁的定义是：**绝对时间上最先请求锁资源的线程会最先获取锁，以及等待获取锁资源时间最长的线程会最优先获取锁，这样的获取锁机制就是公平的**。

[c9c9cf3921fe4b0e9d00ded5a0218477.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/fd594a03be8743d99404cb47e15bd160.png
[6bf8d2e37e37467294551a182c098373.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/2c7b0d0a23f649488010fa90d302d84c.png