JVM本地锁（二）ReentrantLock可重入锁源码解析

系统管理员 2024-03-30 13:29 62阅读 0赞

什么是可重入锁呢  
顾名思义，就是可以重复进入的锁，学过操作系统或者计组的可参照理解pv，或者多重中断。

demo1(){
        
            lock(); //第一次锁
            demo2(){
        
                lock(); // 第二次锁
                unlock(); 
            }
            unlock();
        }

#### 文章目录 ####

*  ReentrantLock
 *   *  lock 加锁
     *   *  1. ReentrantLock.lock()
         *  2. sync.lock()
         *  3. unfairSync.lock()
         *  4. AQS.acquire(1)
     *  unlock 解锁
     *   *  1. ReentrantLock.unlock()
         *  2. AQS.release(1)
         *  3. syn.tryRelease(1)
 *  总结

## ReentrantLock ##

### lock 加锁 ###

![在这里插入图片描述][c84d0192aff04639a4ec3e972e5885aa.png]

#### 1. ReentrantLock.lock() ####

直接从lock()入手翻阅源码

public void lock() {
        
            sync.lock();
        }

它调用的是sync.lock();

#### 2. sync.lock() ####

![在这里插入图片描述][30e9981f54994b28b565af8760044439.png]  
在ReentrantLock初始化时，默认是非公平锁，有参构造true则是公平锁

> 非公平锁：来个线程就先试试能不能插队，不能插队才去后面排队  
> 公平锁：线程都乖乖去后面排队去，不准插队

总而言之，sync就是个内部非公平/公平锁。

再往下看，由于lock()是抽象方法，而sync默认是非公平锁。  
![在这里插入图片描述][63a3beb0d2d64eac9a047728189419ac.png]

调用unfairSync.lock()

#### 3. unfairSync.lock() ####

final void lock() {
        
    		// 若CAS抢到锁，记录设置当前线程
           if (compareAndSetState(0, 1))
              setExclusiveOwnerThread(Thread.currentThread());
           else
           // 若没抢到锁
               acquire(1);
    }

点击compareAndSetState

![在这里插入图片描述][82f378c97ecf469ba4809a1f5f2d7d7e.png]  
这就是CAS获取锁，unsafe是JDK中用于硬件实现CAS的操作。  
不用管它，只需要理解这里就是CAS操作。

> 若state==0，则更新为1，并且设置好排他线程。即该线程成功抢到锁

那如果没抢到锁呢

#### 4. AQS.acquire(1) ####

public final void acquire(int arg) {
        
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

先执行tryAcquire()，可以理解为再次抢锁。

*  如果成功，返回为true，再加个！,成了false，后面就不用执行
 *  如果失败，则执行后面acquireQueued()，即进入等待队列

这里nonfairSync重写方法，直接调用nonfairSync.tryAcquire(1)

![在这里插入图片描述][eebcf2ab685842eba1669ec4420f17e8.png]  
继续往下调用nonfairTryAcquire(1)

final boolean nonfairTryAcquire(int acquires) {
        
                final Thread current = Thread.currentThread();
                int c = getState();
                // 如果state=0，再重新尝试一下看能不能抢到锁
                if (c == 0) {
        
                    if (compareAndSetState(0, acquires)) {
        
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }
                // 如果state不为0
                // 如果这个线程就是之前已经抢到锁的那个，它又要加锁，重入！
                else if (current == getExclusiveOwnerThread()) {
        
                	// state递加上去
                    int nextc = c + acquires;
                    if (nextc < 0) // overflow
                        throw new Error("Maximum lock count exceeded");
                    setState(nextc);
                    return true;
                }
                return false;
            }

简单理解就是

*  如果state==0，再重新CAS抢救一下，看能不能抢到锁，抢到了那就成功
 *  如果state不为0，说明已经被抢了。但是如果那个抢到锁的线程是自己，自己又重入了，那state+1，再次加锁，成功。
 *  如果那个抢到锁的不是自己，加锁失败。

如果加锁失败，则方法返回到AQS.acquire(1)，还需要执行if后面的判断。  
简单看下addWaiter()；

private Node addWaiter(Node mode) {
        
            Node node = new Node(Thread.currentThread(), mode);
            // Try the fast path of enq; backup to full enq on failure
            // tail即尾结点
            Node pred = tail;
            if (pred != null) {
        
                node.prev = pred;
                if (compareAndSetTail(pred, node)) {
        
                    pred.next = node;
                    return node;
                }
            }
            enq(node);
            return node;
        }

这里维护着一个双向链表，简单来说就是把结点放到链表的尾部，并且更新尾结点。  
加锁失败了，把这个线程放在表尾，乖乖排队吧。

这就是加锁的所有过程。

### unlock 解锁 ###

#### 1. ReentrantLock.unlock() ####

![在这里插入图片描述][caf9c803947440debdc0b0ca3c217dba.png]  
很明显，看来这里是将之前的state一个个减1减回来

#### 2. AQS.release(1) ####

public final boolean release(int arg) {
        
            if (tryRelease(arg)) {
        
                Node h = head;
                if (h != null && h.waitStatus != 0)
                    unparkSuccessor(h);
                return true;
            }
            return false;
        }

tryRelease也就是解锁了

#### 3. syn.tryRelease(1) ####

![在这里插入图片描述][5eae630b9b754597a551061cc8346409.png]  
就是将state-1,进行解锁操作。由于可能被可重入了，state-1后不一定为0；如果为0则将记录的线程清空。

解锁很好理解，就不详细赘述了。

## 总结 ##

lock:

*  CAS获取锁，若没有线程占用锁(state==0)，加锁成功并记录当前线程是有锁线程(两次，开始一次，acquire()中又一次）
 *  若state值不为0，说明锁已经被占用，则判断当前线程是否是有锁线程，若是则重入(state+1)
 *  否则加锁失败，入队等待

unlock:

*  判断当前线程是否是有锁线程，不是则抛出异常
 *  state-1, 若-1后state值为0则解锁成功，返回true
 *  若-1后state不为0，则返回false

[c84d0192aff04639a4ec3e972e5885aa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c911e2821005486f8f5cbec4a7ff91b4.png
[30e9981f54994b28b565af8760044439.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/97c74f728e6c4ec0a18838d8a3661b81.png
[63a3beb0d2d64eac9a047728189419ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/153e949428c04c3ab351b4abf979736a.png
[82f378c97ecf469ba4809a1f5f2d7d7e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4d85c05c0c7d489cb6d655685becab1f.png
[eebcf2ab685842eba1669ec4420f17e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/eae102fa24f1432fb54d9f899683730e.png
[caf9c803947440debdc0b0ca3c217dba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2ac52a28e43440f3a53dab3c95a987e8.png
[5eae630b9b754597a551061cc8346409.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c9ba960c85a14c1984cec7d1794775fe.png