AQS为什么用双向链表？

news2024/11/20 14:33:17

首先，在AQS中，等待队列是通过Node类来表示的，每个Node节点包含了等待线程的信息以及等待状态。下面是Node类的部分源码：

static final class Node {
    // 等待状态
    volatile int waitStatus;
    // 前驱节点
    volatile Node prev;
    // 后继节点
    volatile Node next;
    // 等待线程
    volatile Thread thread;
    // 等待条件
    Node nextWaiter;

    // ...省略其他代码...
}

从上面的代码可以看出，每个Node节点都有一个指向前驱节点和后继节点的指针，这样可以在O(1)时间内查找前驱和后继节点。

接下来，我们来看看AQS是如何使用双向链表来管理等待队列的。AQS内部有一个成员变量volatile Node head，它表示等待队列的头节点。当一个线程需要等待锁或条件时，它会创建一个Node节点并插入到等待队列的尾部。这个过程是通过以下方法实现的：

private Node addWaiter(Node mode) {
    // 创建一个Node节点，表示当前线程
    Node node = new Node(Thread.currentThread(), mode);
    // 尝试通过CAS操作将Node节点插入到等待队列的尾部
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

在上面的代码中，首先创建了一个Node节点表示当前线程，然后尝试通过CAS操作将它插入到等待队列的尾部。如果CAS操作失败，说明有其他线程正在修改等待队列，此时会调用enq()方法来将节点插入到队列中。

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // 如果队列为空，需要先初始化队列
            if (compareAndSetHead(new Node()))
                tail = head;
        } else { // 如果队列不为空，将节点插入到队列尾部
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

在enq()方法中，首先获取等待队列的尾节点，如果尾节点为空，说明队列还没有初始化，需要先创建一个空的头节点来初始化队列。如果尾节点不为空，就将新的节点插入到尾节点的后面。如果CAS操作失败，说明有其他线程正在修改等待队列，这时需要重新尝试。

当一个线程持有锁的线程释放锁时，它会将等待队列的头节点出队并唤醒它的后继节点，这个过程是通过以下方法实现的：

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

private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    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;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}

在上面的代码中，首先将头节点设置为当前节点，然后将头节点的prev指针置为null，表示它已经出队了，将头节点的thread指针置为null，表示当前线程不再持有锁。接下来，通过unparkSuccessor()方法唤醒后继节点。这个方法中，首先检查当前节点的等待状态，如果它的等待状态小于0，说明它是一个被取消的节点，将它的等待状态置为0。然后，找到当前节点的后继节点，如果它不存在或者它的等待状态大于0，说明它不能被唤醒，这时就需要从等待队列的尾部开始往前找，找到一个等待状态小于等于0的节点来唤醒。最后，通过LockSupport.unpark()方法唤醒后继节点的线程。

从双向链表的特性来看，我认为AQS使用双向链表有三个方面的考虑。

第一个方面，没有竞争到锁的线程加入到阻塞队列，并且阻塞等待的前提是，当前线程所在节点的前置节点是正常状态，

这样设计是为了避免链表中存在异常线程导致无法唤醒后续线程的问题。

所以线程阻塞之前需要判断前置节点的状态，如果没有指针指向前置节点，就需要从head节点开始遍历，性能非常低。