AQS解锁原理

傷城~ 2022-10-16 07:21 146阅读 0赞

# ReectrantLock 和 AQS 是什么关系 #

ReectrantLock 是在 AQS 外面包了一层，ReectrantLock 所有的加锁、解锁、打断、取消等等，底层都是交给 AQS完成的。

# ReectrantLock 标准使用方式 #

class X { 
       private final ReentrantLock lock = new ReentrantLock();
       // ...
    
       public void m() { 
         // 加锁
         lock.lock();  // block until condition holds
         try { 
            // 被加锁的代码块
           // ... method body
         } finally { 
           // 解锁
           lock.unlock()
         }
       }

# 解锁过程 #

public void unlock() { 
        // 调用非公平锁的释放锁方法。 
        sync.release(1);
    }

public final boolean release(int arg) { 
        // 释放锁，
        if (tryRelease(arg)) { 
            // 拿头结点。
            Node h = head;
            // t头结点不是空，而且头结点的 waitStatus 此时是 -1。
            if (h != null && h.waitStatus != 0)
                // 唤醒离头结点最近的没有被取消的节点。
                // 这里是传了头结点进去。
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

释放锁的细节：

protected final boolean tryRelease(int releases) { 
        // 这跟锁重入有关系，当 c == 0 时，才能释放成功。
        // 比如，T0 加锁四次，getState() == 4，释放三次 releases ==3
        // c=4-3, T0 当然不能释放成功，还有一层锁呢。
        int c = getState() - releases;
        // 如果当前线程不是锁的持有者，抛异常。
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        // 当 c==0 时，锁才能释放成功。
        if (c == 0) { 
            free = true;
            // 将同步器中锁的持有者置为 null。
            setExclusiveOwnerThread(null);
        }
        // CAS 修改 state = 0。
        setState(c);
        // 返回
        return free;
    }

唤醒离头结点最近的没有被取消的节点，在头结点后面 可能有节点（线程）已经被取消了，那就将这些被取消的线程从队列中移除，这个样的话，第一个没有被取消的节点就放在了头结点后面，也就是队列中的第二个节点的位置。

// node == head
    private void unparkSuccessor(Node node) { 
        // ws == -1
        int ws = node.waitStatus;
        if (ws < 0)
            // 设置队头节点的 waitStatus == 0
            compareAndSetWaitStatus(node, ws, 0);    
        // s 先指向队列中的第二个节点。
        Node s = node.next;
        // 如果第二个节点是空，或者被取消了。
        if (s == null || s.waitStatus > 0) { 
            s = null;
            // t 从队尾开始，朝着队头的方向，扫一遍队列中的所有节点。
            for (Node t = tail; t != null && t != node; t = t.prev)
                // s 指向离队头最近的且没有被取消的线程节点。
                if (t.waitStatus <= 0)
                    s = t;
        }
        // unpark s 指向的节点中的线程。
        if (s != null)
            LockSupport.unpark(s.thread);
    }

唤醒 node 后，node还要继续去竞争锁。

final boolean acquireQueued(final Node node, int arg) { 
        boolean failed = true;
        try { 
            boolean interrupted = false;
            // 死循环
            for (;;) { 
                // 被唤醒后又一次循环, 此时被唤醒的节点是队列中的第二个节点。
                // 获取前驱。
                final Node p = node.predecessor();
                // 前驱一定是头结点。竞争锁
                if (p == head && tryAcquire(arg)) { 
                    // 竞争成功，出队执行线程逻辑。
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                // 竞争失败，继续追加到队列里 park。
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt()) // 从这里唤醒的。
                    interrupted = true;
            }
        } finally { 
            if (failed)
                cancelAcquire(node);
        }
    }

被唤醒变了怎么还要去竞争锁，而且还有失败的可能性？

因为这是非公平锁，既有被唤醒的，可能同时还有刚产生的线程，两者会竞争锁。

# 总结 #

释放锁过程做三件事情：

1.  释放锁
2.  唤醒离头结点最近的第一个没有被取消的 node。
3.  被唤醒的 node 再去竞争锁，成功，node出队执行逻辑代码，失败，继续追加到队列里 park。