难以理解的锁（一） ReentrantLock

ゞ浴缸里的玫瑰 2024-04-18 08:21 59阅读 0赞

### 文章目录 ###

*   *  一、AbstractQueuedSynchronizer
     *  二、ReentrantLock
     *   *   *  线程 t1 首次申请
             *  线程 t2 获取已被占有的锁
             *  线程 t1 解锁
             *  如何公平
             *  取消获取锁
             *  如何非公平

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

## 一、AbstractQueuedSynchronizer ##

属性

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>类型</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>state</td> 
   <td>int</td> 
   <td>表示是否被线程持有，0表示没有，n表示线程重入次数</td> 
  </tr> 
  <tr> 
   <td>head</td> 
   <td>Node</td> 
   <td>线程阻塞队列的头节点，head表示正在持有锁的线程</td> 
  </tr> 
  <tr> 
   <td>tail</td> 
   <td>Node</td> 
   <td>线程阻塞队列的尾节点，未竞争到锁的Node将添加至队列尾部</td> 
  </tr> 
  <tr> 
   <td>unsafe</td> 
   <td>Unsafe</td> 
   <td>含有CAS原子操作的类，调用本地方法实现</td> 
  </tr> 
  <tr> 
   <td>exclusiveOwnerThread</td> 
   <td>Thread</td> 
   <td>继承AbstractOwnableSynchronizer类的字段，表示当前持有锁的线程</td> 
  </tr> 
 </tbody> 
</table>

Node 属性

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>类型</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>thread</td> 
   <td>Thread</td> 
   <td>线程对象</td> 
  </tr> 
  <tr> 
   <td>prev</td> 
   <td>Node</td> 
   <td>指向队列中前一个节点</td> 
  </tr> 
  <tr> 
   <td>next</td> 
   <td>Node</td> 
   <td>指向队列中后一个节点</td> 
  </tr> 
  <tr> 
   <td>waitStatus</td> 
   <td>int</td> 
   <td>等待状态，1表示线程取消等待，-1表示后一个节点该被唤醒，-2，-3暂时不用</td> 
  </tr> 
 </tbody> 
</table>

锁实现的思路：  
1 CAS操作更新state，比如将0更新为1，成功表示竞争到了锁，操作失败则竞争失败，需要加入阻塞队列  
2 将线程对象封装为Node，加入队列尾部，可能同时有多个线程操作，所以这一步也是CAS操作  
3 解锁操作将state更新为0，唤醒队列中下一个线程Node，解锁的线程Node从队列中移除

## 二、ReentrantLock ##

ReentrantLock 中有个 Sync 属性，Sync 抽象类继承自 AQS，在 ReentrantLock 内部有非公平（NonfairSync）和公平（FairSync）两种实现，先学习 FairSync。

**结合场景理解代码：**

#### 线程 t1 首次申请 ####

假设只有线程t1获取锁，执行lock方法：  
FairSync\#lock

final void lock() { 
                acquire(1);
            }

AbstractQueuedSynchronizer\#acquire

public final void acquire(int arg) { 
        	// 尝试获取锁
        	// 获取失败表示竞争且失败,加入队列中（具体逻辑后面分析）
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

FairSync\#tryAcquire

protected final boolean tryAcquire(int acquires) { 
                final Thread current = Thread.currentThread();
                int c = getState();
                // state=0表示可竞争状态
                if (c == 0) { 
                	// 如果队列中没有等待线程（公平锁，如果队列有等待的线程，当前线程就没有资格获取锁了）
                	// 再CAS操作更新state，失败说明同一时间其他线程获取到了锁
                	// 成功设置独占标记为当前线程
                    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;
                }
                // 返回fasle表示锁已经被持有或者竞争失败
                return false;
            }

如果只有一个线程t1获取锁，则在tryAcquire方法CAS这一步成功获取到锁。

#### 线程 t2 获取已被占有的锁 ####

如果在 **t1持有锁** 的状态下，t2线程获取锁，执行tryAcquire一定是失败的，这时会执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)这一句。  
AbstractQueuedSynchronizer\#addWaiter

private Node addWaiter(Node mode) { 
        	// 将当前线程封装在Node中，构造方法第二参数表示是独占还是共享
            Node node = new Node(Thread.currentThread(), mode);
            // Try the fast path of enq; backup to full enq on failure
            Node pred = tail;
            // 如果队尾不为空,CAS更新tail，成功则将调整队列指向至正确，返回当前node
            if (pred != null) { 
                node.prev = pred;
                if (compareAndSetTail(pred, node)) { 
                    pred.next = node;
                    return node;
                }
            }
            // 如果tail指向是空或者CAS更新失败执行enq
            enq(node);
            return node;
        }

AbstractQueuedSynchronizer\#enq

private Node enq(final Node node) { 
        	// 循环
            for (;;) { 
                Node t = tail;
                // 如果tail为null说明队列为空，初始化队列，这里也会存在竞争所以依然CAS操作
                if (t == null) {  // Must initialize
                    if (compareAndSetHead(new Node()))
                        tail = head;
                } else { 
                	// CAS更新队尾Node直到成功,返回队尾当前线程node
                    node.prev = t;
                    if (compareAndSetTail(t, node)) { 
                        t.next = node;
                        return t;
                    }
                }
            }
        }

这时队列为空，需要初始化队列，然后t2线程node加入队列：  
![在这里插入图片描述][20190903235259797.PNG]

AbstractQueuedSynchronizer\#acquireQueued

final boolean acquireQueued(final Node node, int arg) { 
            boolean failed = true;
            try { 
                boolean interrupted = false;
                for (;;) { 
                	// 获取前一个node
                    final Node p = node.predecessor();
                    // 前一个node是头，尝试获取锁，如果成功当前node成为头，解放原head
                    // 尝试获取失败说明还有线程在持有
                    if (p == head && tryAcquire(arg)) { 
                        setHead(node);
                        p.next = null; // help GC
                        failed = false;
                        return interrupted;
                    }
                    // 不是head或者获取锁失败，设置前个node中waitState标记为-1即等待状态
                    if (shouldParkAfterFailedAcquire(p, node) &&
                    	// 已经是-1时，停止当前线程
                        parkAndCheckInterrupt())
                        interrupted = true;
                }
            } finally { 
                if (failed)
                	// 执行到这里说明出现异常，取消获取，后面再分析
                    cancelAcquire(node);
            }
        }

AbstractQueuedSynchronizer\#shouldParkAfterFailedAcquire

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { 
            int ws = pred.waitStatus;
            // 如果-1表示下个节点需要唤醒
            if (ws == Node.SIGNAL)
                return true;
            // 如果1表示线程取消锁竞争，将其这些移除，直到找到一个不是取消状态的指向自己
            if (ws > 0) { 
                do { 
                    node.prev = pred = pred.prev;
                } while (pred.waitStatus > 0);
                pred.next = node;
    		// 0 -2 -3 则将设置为-1
            } else { 
                compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
            }
            return false;
        }

AbstractQueuedSynchronizer\#parkAndCheckInterrupt

private final boolean parkAndCheckInterrupt() { 
        	// 停止当前线程，底层用了unsafe.park
            LockSupport.park(this);
            // 返回线程中断状态，先不管
            return Thread.interrupted();
        }

在 线程t1 还在持有锁的情况下，上面代码的目的是将当前线程node的前驱node状态（waitState）设置为-1，表示下一个node的线程需要被唤醒。同时将当前线程停止：  
![在这里插入图片描述][20190905092222866.PNG]  
假设在 线程t1 在持有锁状态下，又来一个线程：  
![在这里插入图片描述][20190905092649604.PNG]

#### 线程 t1 解锁 ####

解锁调用unlock方法，同一时间只会有一个线程解锁  
AbstractQueuedSynchronizer\#release

public final boolean release(int arg) { 
        	// 尝试释放，如果成功，唤醒队列中下一个线程
            if (tryRelease(arg)) { 
                Node h = head;
                if (h != null && h.waitStatus != 0)
                    unparkSuccessor(h);
                return true;
            }
            return false;
        }

Sync\#tryRelease

protected final boolean tryRelease(int releases) { 
                int c = getState() - releases;
                // 如果解锁的线程不是占有锁的线程，抛出非法异常
                if (Thread.currentThread() != getExclusiveOwnerThread())
                    throw new IllegalMonitorStateException();
                boolean free = false;
                // state为0表示没有线程占有锁，设置exclusiveOwnerThread为null表示没有线程占有
                if (c == 0) { 
                    free = true;
                    setExclusiveOwnerThread(null);
                }
                // 更新state
                setState(c);
                return free;
            }

AbstractQueuedSynchronizer\#unparkSuccessor

private void unparkSuccessor(Node node) { 
    		// 这里node是head，如果waitState<0，更新状态为0
            int ws = node.waitStatus;
            if (ws < 0)
                compareAndSetWaitStatus(node, ws, 0);
    
    		// 可能队列中有取消的节点，从后往前找到可以需要唤醒的node，忽略已取消的node，为什么从后向前？
            Node s = node.next;
            if (s == null || s.waitStatus > 0) { 
                s = null;
                for (Node t = tail; t != null && t != node; t = t.prev)
                    if (t.waitStatus <= 0)
                        s = t;
            }
            // 如果head的后一个节点不是null，说明队列有等待的线程，将其唤醒
            if (s != null)
                LockSupport.unpark(s.thread);
        }

队列中的线程在 AbstractQueuedSynchronizer\#acquireQueued 方法的 parkAndCheckInterrupt 方法中阻塞，就是那个for循环，被唤醒后会继续循环。被唤醒的线程获取到锁并成为head。

for (;;) { 
                	// 前驱node为head并且获取到锁，当前线程竞升为head
                    final Node p = node.predecessor();
                    if (p == head && tryAcquire(arg)) { 
                        setHead(node);
                        p.next = null; // help GC
                        failed = false;
                        return interrupted;
                    }
                    if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                        interrupted = true;
                }

AbstractQueuedSynchronizer\#setHead

private void setHead(Node node) { 
            head = node;
            node.thread = null;
            node.prev = null;
        }

线程t1 **解锁**，唤醒 线程t2 后：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRlX2Zyb2c_size_16_color_FFFFFF_t_70]  
**为什么从后向前遍历找需要唤醒的线程？**  
1 首先满足 (s == null || s.waitStatus > 0) 才会进入遍历，如果head的next节点不是null且waitState<=0就会直接唤醒next的线程。  
2 head.next（即s）什么时候会是null？

node.prev = t;
                    if (compareAndSetTail(t, node)) { 	// 1
                        t.next = node;					// 2
                        return t;
                    }

在enq方法和addWaiter方法中都有上面代码片段，t表示tail的node。先将当前node指向tail，CAS更新队尾node，成功后将tail的next指向当前node。整个操作不是原子的，有可能出现下面两种情况：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRlX2Zyb2c_size_16_color_FFFFFF_t_70 1]  
如果类似图中第二种情况，那么head.next为null，但是其实队列中有等待线程，所以需要从队尾在遍历到当前node看看有没有需要唤醒的node。

#### 如何公平 ####

在 FairSync\#tryAcquire 方法中尝试加锁时，需要先判断队列中是否有线程排队，如果没有才进行CAS更新state。先到队列的线程线程先获得锁。

if (c == 0) { 
                    if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) { 
                        setExclusiveOwnerThread(current);
                        return true;
                    }
                }

AbstractQueuedSynchronizer\#hasQueuedPredecessors

public final boolean hasQueuedPredecessors() { 
            // The correctness of this depends on head being initialized
            // before tail and on head.next being accurate if the current
            // thread is first in queue.
            Node t = tail; // Read fields in reverse initialization order
            Node h = head;
            Node s;
            return h != t &&
                ((s = h.next) == null || s.thread != Thread.currentThread());
        }

head == tail 情况有以下两种情况，一是队列没有初始化过都是null，二是队列中保留一个thread为null，waitState为0的node，这两种情况都表示队列中已经没有排队线程。  
![在这里插入图片描述][20190905110220726.PNG]  
还有一种情况就是head.next的线程和当前线程是同一个，返回也是false，因为满足可重入的条件。

#### 取消获取锁 ####

在acquireQueued方法try-finally的finally代码块中有取消获取锁的操作，正常情况不会执行，当有异常时执行。\*\*可能发生的异常就是超过了最大锁计数 和 队列中当前线程的前驱为null。\*\*个人认为两种都不可能出现（可能太笨了看不懂）。那就看看怎么取消的吧。  
AbstractQueuedSynchronizer\#cancelAcquire

private void cancelAcquire(Node node) { 
            // Ignore if node doesn't exist
            if (node == null)
                return;
    
            node.thread = null;
            
            // 找到前面不是取消状态的node
            Node pred = node.prev;
            while (pred.waitStatus > 0)
                node.prev = pred = pred.prev;
    
            Node predNext = pred.next;
    		// 设置当前node的状态为1
            node.waitStatus = Node.CANCELLED;
    
            // 如果当前node是tail则移除，同时移除了其他取消状态的node
            if (node == tail && compareAndSetTail(node, pred)) { 
                compareAndSetNext(pred, predNext, null);
            } else { 
            	// 这段有点复杂，没太看懂，我理解的是从队列中移除，如果前驱是head则唤醒后续node的线程
                // If successor needs signal, try to set pred's next-link
                // so it will get one. Otherwise wake it up to propagate.
                int ws;
                if (pred != head &&
                    ((ws = pred.waitStatus) == Node.SIGNAL ||
                     (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                    pred.thread != null) { 
                    Node next = node.next;
                    if (next != null && next.waitStatus <= 0)
                        compareAndSetNext(pred, predNext, next);
                } else { 
                    unparkSuccessor(node);
                }
    
                node.next = node; // help GC
            }
        }

#### 如何非公平 ####

ReentrantLock默认是非公平实现的，Sync的实现类为NonfairSync，相较与FairSync其实也只有lock时一点不同：  
1 lock方法首先CAS操作尝试获取锁，如果失败在调用acquire方法  
2 tryAcquire中调用nonfairTryAcquire方法，获取锁时不考虑队列中是否有等待线程，直接参与竞争  
NonfairSync\#lock

final void lock() { 
            	// 直接尝试获取锁
                if (compareAndSetState(0, 1))
                    setExclusiveOwnerThread(Thread.currentThread());
                else
                    acquire(1);
            }

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

如果tryAcquire失败也需要进入队列，与公平锁一样。可能出现队列中线程一直获取不到锁，造成锁饥饿现象。

（20190905）

[20190903235259797.PNG]: https://img-blog.csdnimg.cn/20190903235259797.PNG
[20190905092222866.PNG]: https://img-blog.csdnimg.cn/20190905092222866.PNG
[20190905092649604.PNG]: https://img-blog.csdnimg.cn/20190905092649604.PNG
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRlX2Zyb2c_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2019090510351417.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRlX2Zyb2c=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRlX2Zyb2c_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190905164824642.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRlX2Zyb2c=,size_16,color_FFFFFF,t_70
[20190905110220726.PNG]: https://img-blog.csdnimg.cn/20190905110220726.PNG