并发编程学习笔记（十三、AQS同步器源码解析2，AQS共享锁）

目录：

• 共享锁和独占锁的区别
• 共享锁实现原理
• 共享锁和独占锁在源码上有何区别

共享锁和独占锁的区别

共享锁和独占锁（排它锁）最大的区别就是，在同一时刻能否有多个线程获取同步状态。

• 独占模式，获取资源后，只有一个线程获取同步状态并执行。
• 共享模式，在获取资源后，多个线程共同执行。

共享锁实现原理

1、加锁：

共享锁和排它锁的实现原理类似，我这次就不具体说明了，直接上源码。

/**
 * 共享模式，获取资源
 */
public final void acquireShared(int arg) {
    // 成功获取资源则结束，失败则进入等待队列
    // 小于0的都任务是获取资源失败，反之大于等于0则是成功
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

同样的tryAcquireShared()也是交给子类实现的加锁函数，可参照CountDownLatch。

protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}

/**
 * CountDownLatch：当状态为0的时候则可以获取锁（共享资源的状态），反之则不能
 */
protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

——————————————————————————————————————————————————————————————————————

接下来我们来看下获取资源失败，进入队列等待执行了什么逻辑。

private void doAcquireShared(int arg) {
    // 自旋添加共享模式待队尾，与独占模式一致，只是入参不同
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                // r >= 0标识共享资源获取成功
                if (r >= 0) {
                    // 将当前结点设置为头结点，并检查后继节点是否在共享模式下等待
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    if (interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            // 与独占模式类似，校验是否需要阻塞线程，判断中断状态
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

哈哈，是不是和独占锁很像，的确！

但也有些不同，共享锁是只有线程是head.next时，也就是线程为头节点的后继节点时才会去尝试获取资源，如果还有其它节点还会唤醒之后的线程。

就这样说你可能会有些疑惑，我来解释下；首先会自旋，也就是会一直轮询第8行那块，直到满足第9行才会去执行第10行；也就是说第8行的p一定是head，而p的值是当前节点的前驱结点，所以p肯定为head的后继节点。

final Node predecessor() throws NullPointerException {
    Node p = prev;
    if (p == null)
        throw new NullPointerException();
    else
        return p;
}

——————————————————————————————————————————————————————————————————————

上面说到如果还有其它节点还会唤醒之后的线程，那么问题来了。

假如老大用完后释放了5个资源，而老二需要6个，老三需要1个，老四需要2个。 老大先唤醒老二，老二发现自己的资源都不够，老二是否把资源让给老三呢？

答案是否定的，老二会继续park()等待其它线程释放资源，更不会唤醒老三和老四。

——————————————————————————————————————————————————————————————————————

接下来就是我们共享锁的重点部分了，setHeadAndPropagate()。

/**
 * 成为头节点，并在满足条件时唤醒后继节点
 */
private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    // 把当前节点设为头节点
    setHead(node);
    /*
     * 满足以下三种情况执行唤醒操作：
     * 1、propagate > 0，标识后继节点需要被唤醒（AQS默认只有一个是大于0的，就是线程取消，CANCELLED）
     * 2、原头节点为null或ws < 0
     * 3、新的头节点（也就是当前节点）为null或ws < 0
     */
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        // 若s == null或s是共享模式，则唤醒后继线程
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

这部分也不是很难，你应该能很快的理解它。

——————————————————————————————————————————————————————————————————————

在上述setHeadAndPropagate()中说道满足特定条件且是共享模式时会唤醒后继线程，也就是调用doReleaseShared()，这其实就是一个解锁的过程，我们来看看具体的实现。

private void doReleaseShared() {
    /*
     * 自旋后释放后继节点
     */
    for (;;) {
        Node h = head;
        // 表示队列中至少有2个节点
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            // ws == SIGNAL（后继节点需要被唤醒）
            if (ws == Node.SIGNAL) {
                // 通过CAS设置h的waitStatus字段为0
                if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0))
                    // CAS失败则继续自旋
                    continue;            // loop to recheck cases
                // CAS成功，则唤醒后继节点，执行过程同独占模式下的唤醒流程
                unparkSuccessor(h);
            }
            // 同上，若h是初始状态0，则CAS为PROPAGATE（表示锁的下一次获取可以“无条件传播”）
            else if (ws == 0 &&
                     !h.compareAndSetWaitStatus(0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        // 自旋的跳出条件，head不变则跳出，变化则一直自旋
        // head不变表示设置完成，可以退出循环
        // head变化，可能被唤醒的其它节点重新设置了头节点，这样头节点发生了变化，需要进行重试，保证可以传播唤醒型号
        if (h == head)                   // loop if head changed
            break;
    }
}

至此acquireShared()已经解析完成了，我们来总结下：

1、首先tryAcquireShared()尝试获取资源，成功则直接返回；失败则通过doAcquireShared()进入等待队列park()， 直到被unpark()/intemupt()并成功获取到资源才返回。整个等待过程也是忽略中断的。

2、其实跟acquire()的流程大同小异，只不过多了个自己拿到资源后，还会去唤醒后继队友的操作（这才是共享嘛）。 

——————————————————————————————————————————————————————————————————————

2、解锁：

解锁这个东西啊你只要把上面弄懂了，就是小事情了，我不再赘述了，哈哈。

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

共享锁和独占锁在源码上有何区别

1、获取资源

• 共享锁（doAcquireShared()）：
  • 是只有线程是head.next时，也就是线程为头节点的后继节点时才会去尝试获取资源。
  • 如果还存在其它节点，还会唤醒之后的线程，也就是自己执行完之后还会叫队友来获取资源。
• 独占锁（acquireQueued()）：
  • 同共享锁，但不仅要线程为头节点的后继节点，还需要获取到锁。
  • 独占锁执行完后就结束了，不会唤醒队友（脏线男枪，哈哈哈哈哈哈）。

2、释放资源：同样的共享锁会唤醒队友，而独占锁不会。