【JUC源码】JUC核心：AQS（二）同步队列源码分析（独占锁）

AQS 系列：

• 【JUC源码】JUC核心：AQS（一）底层结构分析
• 【JUC源码】JUC核心：AQS（二）同步队列源码分析（独占锁）
• 【JUC源码】JUC核心：AQS（三）同步队列源码分析（共享锁）
• 【JUC源码】JUC核心：AQS（四）条件队列源码分析
• 【JUC源码】JUC核心：关于AQS的几个问题

同步队列：

• 作用：管理多个线程的休眠与唤醒
• 策略：可以执行的线程 = RUNNABLE 状态 && tryAcquire() 成功
  • 独占模式（EXCLUSIVE）：队首持锁，唤醒队二后 tryAcquire() 尝试拿锁，队三及以后休眠
  • 共享模式（SHARED）：相较于独占模式只唤醒队二 ，共享模式还唤醒所有 mode=shared 节点（多了一步）
    注：这里需要明确一点，独占和共享是对于加锁而言（能否多线程同时获锁），释放锁时没有独占和共享的概念
• 状态
  • 初始化（0）：入队的初始状态
  • SIGINAL（-1）：若当前 node 后面还有 node，就要从 0->SIGNAL
  • CANCELLED（1）：拿锁失败或出现异常，会在置为 CANCELLED 后删除，但并发时可能会暂时维持

1.独占-加锁

acquire()

该方法用作获取锁。排他模式下，acquire 方法由子类的 lock 方法直接调用。如下图是 Reentrantlock 的静态内部类 Sync 和 NonfairSync：

注：从图中也可以看出 NonfairSync 的 lock 方法是非公平的，因为当前线程直接就有获取锁的机会（CAS修改state成功），不是必须要进入同步队列，接受同步器的调度。

• 尝试获得锁，成功直接放回
• 失败，加入同步队列，等待拿锁

public final void acquire(int arg) {
    // tryAcquire 方法是需要子类去实现的
    // CAS修改state判断能否拿到锁,拿到锁return true，不会再进入addWaiter
    if (!tryAcquire(arg) &&
        // addWaiter 入参代表是排他模式
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

PS：这里一定要明白，AQS 中并没有实现 tryAcquire() 方法，它是交由子类去实现的，因为它是使用 AQS 加锁的关键。

如下图，是 Reentrantlock中 NonfairSync 的 tryAcquire 方法的具体实现

// Reentrantlock.sync#nonfairTryAcquire()
final boolean nonfairTryAcquire(int acquires) {
	// 获取当前线程
    final Thread current = Thread.currentThread(); 
    // 获取当前同步器的状态
    int c = getState(); 
    // 若c=0，表示没有线程持锁，即有机会获取锁
    if (c == 0) { 
    	// 尝试将state通过CAS设置为1 
        if (compareAndSetState(0, acquires)) { 
        	// 若CAS成功，表示当前线程可以拿锁，则将拿锁线程设为当前
            setExclusiveOwnerThread(current); 
            return true; // 返回true
        }
    }
    // 如果当前线程已经获得锁了
    else if (current == getExclusiveOwnerThread()) { 
    	 // 重入，+1
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc); 
        // 返回true
        return true; 
    }

	// 否则，返回false，表示获取不到锁
    return false; 
}

addWaiter()

回到 acquire() ，可以看到 tryAcquire() 后，就是 addWaiter()，将等待的线程加入同步队列。

PS：这里注意一点，对于同步队列节点的所有操作，都要是线程安全的，即通过 CAS

private Node addWaiter(Node mode) {
    // 创建并初始化 Node
    Node node = new Node(Thread.currentThread(), mode);
    // 在自旋前，先尝试看能否直接加到队尾，若成功直接返回
    // 这种做法大部分都可以一次成功，节省了自旋的开销
    Node pred = tail;
    // 当前同步队列不能为空，因为为空时还要设置head
    if (pred != null) {
		// 将新节点node的前置节点设置为tail（双向链表）
        node.prev = pred; 
        // 为了保证线程安全，CAS交换尾结点，然后再连接上一个tail
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 当直接加入队列失败（即CAS失败或者队列为空），需要通过自旋保证node加入到队尾
    enq(node);
    return node;
}

enq()

• 线程加入同步队列中方法，追加到队尾
• 这里需要重点注意的是，返回值是添加 node 的前一个节点

private Node enq(final Node node) {
    // 自旋，保证在出现竞争时也能安全加入同步队列
    for (;;) {
        // 得到队尾节点
        Node t = tail;
        // 如果队尾为空，说明当前同步队列都没有初始化
        // tail = head = new Node();
        if (t == null) {
        	// 则新建一个空 node 作为头
            if (compareAndSetHead(new Node()))
                tail = head;
        // 队尾不为空，将当前节点追加到队尾
        } else {
            node.prev = t;
            // node 追加到队尾
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }

acquireQueued（核心方法)

管理同步队列（拿锁+休眠）

• 队二尝试拿锁，成功后取代队首
  • 同步队列队首是已经获得锁的节点
  • 队二有两种情况：1.新node进入直接就是队二 2.队n被唤醒后发现此时他已经前进了到了队二
  • 若队二拿锁失败（非公平锁），则（继续）进入休眠；但是它仍是队二，队首也没删
• 阻塞队3-队n
  • 前提是自旋使自己前一个节点的状态变成 signal（SIGNAL代表后面一定有待唤醒，不会被遗忘）
  • 等线程一个个醒来后，再尝试拿锁

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        // 自旋
        for (;;) {
            // predecessor是Node中的方法，作用是放回当前节点的上一个节点（prev）
            final Node p = node.predecessor();
 
            // 队二是有资格夺锁（tryAcquire）的节点
            // 若成功则把自己设置为队首，失败就（再）进入休眠
            if (p == head && tryAcquire(arg)) { // 如果当前节点是队二，且可以获取到锁
                // 将当前node置为head，实际上就是删除已经释放锁的节点
                setHead(node);
                // p（之前获得锁的节点）被回收，next置为null是为了help gc
                p.next = null; 
                failed = false;
                return interrupted;
            }

            // shouldParkAfterFailedAcquire 检验node能否休眠（pre=SIGNAL)，若不能则设置pre=SIGNAL
            // parkAndCheckInterrupt 阻塞当前线程
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 线程是在这个方法里面阻塞的，醒来的时候仍然在无限 for 循环里面，就能再次自旋尝试获得锁
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        // 如果获得node的锁失败或异常，将 node 置为 CANCELLED，并删除
        // 因此，在并发情况下，同步队列中的任何位置节点都可能短暂CANCELLED，但最后一定会被删掉
        if (failed)
            cancelAcquire(node);
    }
}

• setHead()

排他模式下，获得锁的节点，一定会被设置成头节点

private void setHead(Node node) {
    // 将head设置为当前ndoe
    head = node; 
    // 将获得锁的线程置null
    node.thread = null;
    node.prev = null;
}

shouldParkAfterFailedAcquire()

校验能否安全休眠：当前线程可以安心阻塞的标准，就是前一个节点线程状态是 SIGNAL 了

• 前一个结点是SIGNAL，return true
• 前一个节点不是SIGNAL，return false（因为上层调用是自旋，所以最后一定能SIGNAL)
  • waitStatus>0(已取消)：依次向前寻找，挂到一个未取消节点后面
  • waitStatus<=0 但不是SIGNAL，就将前一个结点设为SIGNAL

// 入参 pred 是前一个节点，node 是当前节点。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    // 如果前一个节点 waitStatus 状态已经是 SIGNAL 了，直接返回，不需要在自旋了
    if (ws == Node.SIGNAL)
        return true;
    // 如果前一个节点状态已经被取消了
    if (ws > 0) {
        // 找到前一个状态不是取消的节点，因为把当前 node 挂在有效节点身上
        // 因为节点状态是取消的话是无效的，是不能作为 node 的前置节点的，所以必须找到 node 的有效节点才行
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    // 否则直接把前一个结点状态置 为SIGNAL
    } else {
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

parkAndCheckInterrupt()

通过park休眠当前线程，到时需要unpark唤醒

private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
}

这里最终调用的 Unsafe 类，是位于sun.misc包下的一个类，可以用来在任意内存地址位置处读写数据，支持一些CAS原子操作。Java 最初被设计为一种安全的受控环境。尽管如此，HotSpot 还是包含了一个后门 sun.misc.Unsafe，提供了一些可以直接操控内存和线程的底层操作。

park 及 unpark 底层其实是调用了操作系统的 Mutex互斥量、Condition 信号量、_counter计数器

• park主要流程：
  • 当_counter > 0，则直接调用 pthread_mutex_unlock 解锁并返回；
  • 当超时时间 time>0，则调用 pthread_cond_timedwait 进行超时等待，直到超时时间到达；
  • 当超时时间 time=0，则调用 pthread_cond_wait 等待；
  • 当 wait 返回时设置_counter = 0，并调用 pthread_mutex_unlock 解锁；
• unpark主要流程：
  • 调用pthread_mutex_lock获取锁，设置_counter=1，调用pthread_mutex_unlock解锁；
  • 若_counter的原值等于0，则调用pthread_cond_signal进行通知处理；

PS：所以，并不是说 AQS 就全部都在用户态完成了，无论是 AQS 还是 synchronized 的阻塞，都需要借助操作系统底层的互斥量、信号量。本质上都是线程的阻塞、唤醒，都会涉及线程状态切换。关于 park 相关源码可以参考这篇文章…

cancelAcquire()

在node获得锁过程中失败或出现异常，就将 node 设为 CANCELLED，然后删除；并发下可能短暂维持

private void cancelAcquire(Node node) {
  	// 将无效节点过滤
	if (node == null)
		return;
  	// 设置该节点不关联任何线程，也就是虚节点
	node.thread = null;
	Node pred = node.prev;
  	// 通过前驱节点，跳过取消状态的node
	while (pred.waitStatus > 0)
		node.prev = pred = pred.prev;
  	// 获取过滤后的前驱节点的后继节点
	Node predNext = pred.next;
  	// 把当前node的状态设置为CANCELLED
	node.waitStatus = Node.CANCELLED;
  	// 如果当前节点是尾节点，将从后往前的第一个非取消状态的节点设置为尾节点
  	// 更新失败的话，则进入else，如果更新成功，将tail的后继节点设置为null
	if (node == tail && compareAndSetTail(node, pred)) {
		compareAndSetNext(pred, predNext, null);
	} else {
		int ws;
    	// 如果当前节点不是head的后继节点，1:判断当前节点前驱节点的是否为SIGNAL，
    	// 2:如果不是，则把前驱节点设置为SINGAL看是否成功
    	// 如果1和2中有一个为true，再判断当前节点的线程是否为null
    	// 如果上述条件都满足，把当前节点的前驱节点的后继指针指向当前节点的后继节点
		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 {
      	// 如果当前节点是head的后继节点，或者上述条件不满足，那就唤醒当前节点的后继节点
			unparkSuccessor(node);
		}
		node.next = node; // help GC
	}
}

2.独占-释放

release()

release() 是 unlock() 的基础方法，用于释放锁。如图是 Reentrantlock 的 unlock 方法，

可以看到，是调用的继承了 AQS 的 Sync 的 release 方法，该方法是在 AQS 中实现的

public final boolean release(int arg) {
    // tryRelease 交给子类去实现
    // 一般就是用当前同步器状态减去 arg，如果返回 true 说明成功释放锁。
    if (tryRelease(arg)) { 
        // 如果可以释放锁，保存头结点head
        Node h = head;
        // 头节点不为空，并且非初始化状态
        if (h != null && h.waitStatus != 0)
            // 唤醒同步队列队二
            unparkSuccessor(h);
        return true;
    }
    return false;
}

下面是 ReentrantLock 的 Sync 的 tryRelease 方法，可以看到，核心是将 AQS 状态置为 0

protected final boolean tryRelease(int releases) {
    int c = getState() - releases; 
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 如果state=0了，就是可以释放锁了
    if (c == 0) { 
        free = true; 
        // 将拿锁线程置为null
        setExclusiveOwnerThread(null); 
    }
    // 重置同步器的state
    setState(c); 
    // 返回是否成功释放
    return free; 
}

unparkSuccessor（核心方法)

找到真正的队二（不是CANCELLED状态)，并唤醒

• head.next 非 null 非 CANCELLED，head.next 就是被唤醒对象
• head.next 如果不行，就从同步队列尾找，防止唤醒的 node 的前置节点仍然是 CANCELLED

注：此时并未删除 head

private void unparkSuccessor(Node node) {
    // node 节点是当前释放锁的节点，也是同步队列的头节点
    int ws = node.waitStatus;
    // 如果节点已经被取消了，把节点的状态置为初始化
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    // 拿出队二s
    Node s = node.next;
    // s 为空，表示 node 的后一个节点为空
    // s.waitStatus 大于0，代表 s 节点已经被取消了
    // 遇到以上这两种情况，就从队尾开始，向前遍历，找到第一个 waitStatus 字段不是被取消的
    if (s == null || s.waitStatus > 0) {
        s = null;
   		
        // 结束条件是前置节点就是head了
        for (Node t = tail; t != null && t != node; t = t.prev)
            // t.waitStatus <= 0 说明 t 当前没有被取消，肯定还在等待被唤醒
            if (t.waitStatus <= 0)
                s = t;
    }
    // 唤醒以上代码找到的线程
    if (s != null)
        LockSupport.unpark(s.thread);
}

到这里需要明确一点，在AQS中，若一个线程释放了锁，接下来只会唤醒一个线程，并不是把所有线程都唤醒，然后大家再去竞争。

•