AbstractQueuedSynchronizer（AQS）源码

最新推荐文章于 2025-05-30 15:59:13 发布

wifi___

最新推荐文章于 2025-05-30 15:59:13 发布

阅读量95

点赞数

分类专栏：源码文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/watermelonmelon_/article/details/128013983

版权

源码专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了Java并发库中的AbstractQueuedSynchronizer（AQS）实现细节，包括如何通过tryAcquire尝试获取锁，如何将线程加入等待队列，以及acquireQueued的循环获取策略。AQS使用节点（Node）数据结构管理等待队列，并通过CAS操作保证线程安全地进入和离开队列。文章深入探讨了AQS在并发控制中的核心机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

public final void acquire(int arg) {
    //tryAcquire(arg)以独占模式获取锁
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
}

//加入队列
private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        
        //enq(node)用以补充上述添加队尾失败的情况
        enq(node);
        return node;
}

//对于这个方法有一个疑问，如果node本身就已经是尾节点了，运行完enq(node)之后，
//尾节点node的prev和next都指向自己 ？
private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
}

//循环尝试获取锁，获取成功后返回“过程中该线程是否被中断”
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                //当前节点为head时，尝试获取锁
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
}