AQS - 抽象同步队列：独占锁的实现

目录

• 属性
  • int state
    • 共享锁 和 独占锁（排他锁）
  • Node head & Node tail
  • Node
• 方法（以独占模式为例）
  • tryAcquire(int arg)
  • acquire(int arg)
    • addWaiter(Node.EXCLUSIVE), arg)
    • acquireQueued(final Node node, int arg)
  • boolean tryRelease(int arg)
  • boolean release(int arg)
    • unparkSuccessor(Node node)

参考链接：https://www.bilibili.com/video/BV12K411G7Fg

通过 CAS ，我们可以实现乐观锁操作，从而使得线程进行同步，但是通过 CAS 的源码，我们发现 CAS 仅仅能修改内存中的一个值，而不是对对象进行同步，那么该如何对对象进行同步呢？同时，在多线程对统一资源进行竞争的情况下，如何能管理到所有需要该资源的线程呢？于是，AQS应运而生。

参考：《深入 Java 虚拟机》

AbstractQueuedSynchronizer抽象同步队列简称AQS，它是实现同步器的基础组件，并发包中锁的底层就是通过AQS实现。结构如下

属性

int state

在共享模式下，需要表示共享锁的持有线程数量。

共享锁 和 独占锁（排他锁）

共享锁：该锁允许被多个线程持有，共享锁仅支持读数据，如果一个线程对数据加了共享锁后，其他数据只能对该数据加共享锁。

独占锁（排他锁）：只有一个线程能获得锁。

共享锁 和 独占锁是 AQS 的不同实现方式

Node head & Node tail

用于维护一个 FIFO 的双向链表，两个 Node 节点分别指向头节点和尾节点

Node

队列中的节点，结构见上图

方法（以独占模式为例）

tryAcquire(int arg)

protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
}

尝试获取锁，获取锁失败直接返回。

该方法仅仅抛出一个异常，AQS 继承类需要继承该方法，用于给上层开放空间，使用户能编写业务逻辑。

acquire(int arg)

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

tryAcquire方法失败后，会进入等待队列

addWaiter(Node.EXCLUSIVE), arg)

主要作用为新建一个 Node 节点，并将节点插入等待队列。

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
    	// 获取当前尾节点，tail 是 AQS 的属性
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            // 尝试通过原子操作将当前节点置为尾节点
            // 其实获取 pred 后，其他线程也可能会对 tail 进行修改
            // compareAndSetTail(Node expect, Node update) 会读取 tail 的偏移
            // 判断当前的 pred 是不是还是队尾（期间可能被其他线程修改），若是，则更新队尾为当前 node
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
    
    	// 调用完整的入队方法，上面尝试快速入队失败时会进入该方法
    	// 例如 tail 被修改的情况
        enq(node);
        return node;
}

acquireQueued(final Node node, int arg)

加入队列后，在队列中自旋对锁进行获取。

经过代码可以看出，head 节点后的节点组成了等待队列

当 head 后第一个 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;
                }
                // 根据目前的节点状态判断线程是否需要挂起
                if (shouldParkAfterFailedAcquire(p, node) &&
                    	parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
}

boolean tryRelease(int arg)

同 tryAcquire ，作为开放给上层的方法

protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
}

boolean release(int arg)

释放锁，并通知队列，改变等待队列中的线程状态

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
            	// 传入 head 并唤醒等待队列中的 node
                unparkSuccessor(h);
            return true;
        }
        return false;
}

unparkSuccessor(Node node)

头节点操作完资源后，通知等待队列中的节点

下方代码的操作中，为什么唤醒不从头节点开始呢

该处搜索并不是原子性的，从后往前搜索，可能会因为队列构建顺序未

1. 后节点 pre 指向前节点
2. 前节点 next 才会指向后节点

从前往后可能会因第2步还未完成而造成搜索中断

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;
            // 从尾节点开始搜索，head 后最靠前的节点并且 waitStatus <= 0 的节点
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
    	// 对找到的节点进行唤醒操作，唤醒后会自旋执行 acquire 方法获取锁
        if (s != null)
            LockSupport.unpark(s.thread);
}

标签：Node,node,AQS,独占,队列,int,线程,arg,节点
来源： https://www.cnblogs.com/Dozeer/p/15481469.html