走近java并发同步器AQS

// AQS静态内部类，作为链表/队列中的数据节点static final class Node {  // 表明是一个共享锁    static final Node SHARED = new Node();  // 表明是一个排它锁    static final Node EXCLUSIVE = null;
  // 上面的节点状态，具体枚举定义见下表，通过cas更新  volatile int waitStatus;
  // 链表前继节点  volatile Node prev;  // 链表后继节点  volatile Node next;  // 节点对应的线程对象  volatile Thread thread;
  // 下一个等待节点，在条件队列中使用；同时也是用来区分排它锁节点和共享锁节点的标识  Node nextWaiter;  //// 此处省略了一些构造函数}

public static void testReentrantLock() {    ReentrantLock reentrantLock = new ReentrantLock();    new Thread(() -> {        System.out.println("线程1开始竞争锁.");        // 排它锁        reentrantLock.lock();        try {            System.out.println("线程1获取锁成功了, 开始执行任务..");            Thread.sleep(5000);        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            System.out.println("线程1完成了要释放锁...");            reentrantLock.unlock();        }    }, "1").start();
    new Thread(() -> {        try {            // 为了让线程1先获取到资源            Thread.sleep(1000);        } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("线程2开始竞争锁.");        reentrantLock.lock();        try {            System.out.println("线程2获取锁成功了, 开始执行任务..");            Thread.sleep(5000);        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            System.out.println("线程2完成了要释放锁...");            reentrantLock.unlock();        }    }, "2").start();
}

// java.util.concurrent.locks.ReentrantLock.NonfairSync
final void lock() {  // cas尝试获取资源，案例中线程1会获取成功，直接返回；    // 线程2会进入else逻辑，竞争锁资源。这里主要看线程2的逻辑  if (compareAndSetState(0, 1))            setExclusiveOwnerThread(Thread.currentThread());        else        // 进入AQS竞争锁，继续往下看          acquire(1);}

// java.util.concurrent.locks.AbstractQueuedSynchronizer
public final void acquire(int arg) {  // 此处的tryAcquire(arg)会尝试cas资源，由AQS子类ReentrantLock实现的  // 1、如果竞争成功则直接返回  // 2、否则调用addWaiter(Node.EXCLUSIVE)，创建一个排它锁节点  // 3、再调用acquireQueued进入队列    if (!tryAcquire(arg) &&        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))        selfInterrupt();}
// 继续看 addWaiter(Node.EXCLUSIVE) 创建排它锁节点private Node addWaiter(Node mode) {  // 创建节点，传入当前线程，表明线程与节点的对应，mode是排它锁的标识    Node node = new Node(Thread.currentThread(), mode);    Node pred = tail;  // 如果尾节点不空    if (pred != null) {      // 将当前线程2所在节点的前继节点指向尾节点        node.prev = pred;      // cas将当前线程2所在节点设置成尾节点，成功的话则返回true        if (compareAndSetTail(pred, node)) {            pred.next = node;            return node;        }    }  // 上面cas操作失败的情况下，会通过轮询不断尝试直至成功，并返回节点    // 当前案例会进入当前方法，因为线程1虽然持有锁，但是没有队列，所以pred=null（tail也为null）    enq(node);    return node;}
// 不断轮询设置尾节点的操作private Node enq(final Node node) {    for (;;) { // 无限循环        Node t = tail;        if (t == null) {             // 没有尾节点，cas一个新节点作为头节点，并且将尾节点也指向它            // 注意：该节点没有对应的线程，可以看作是线程1的            if (compareAndSetHead(new Node()))                tail = head;        } else {       // 再一次循环到此，将线程2的节点设置成尾节点，直至成功。            node.prev = t;            if (compareAndSetTail(t, node)) {                t.next = node;                return t;            }        }    }}
// 继续看调用acquireQueued进入队列，已经通过 addWaiter(Node.EXCLUSIVE) 创建排它锁节点final boolean acquireQueued(final Node node, int arg) {    boolean failed = true;    try {      // 中断标识，但如果中断也不会抛异常        boolean interrupted = false;        for (;;) { // 循环      // 获取线程2节点的前继节点            final Node p = node.predecessor();      // 如果p节点是头节点，此例是的，所以会再次尝试获取下锁            // 聪明啊，真是不放过没一次机会去尝试，如果刚巧线程1此刻执行完任务释放了锁，直接成功获取锁；当然主要应该为了唤醒后获取锁            if (p == head && tryAcquire(arg)) {                setHead(node);                p.next = null; // help GC                failed = false;                return interrupted;            }      // 线程1还没有执行完任务，所以会进入到这里，if中两个判断的方法源码见下文            // parkAndCheckInterrupt()调用LockSupport.park(this);进入线程等待状态，等待唤醒            if (shouldParkAfterFailedAcquire(p, node) &&                parkAndCheckInterrupt())                // 如果线程终端，设置interrupted                interrupted = true;        }    } finally {        if (failed)      // 如果中断/异常，会进行取消节点            cancelAcquire(node);    }}
// 继续看 shouldParkAfterFailedAcquire(p, node)private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {  // 获取前继节点的等待状态，AQS介绍已经说过，默认是0，会经过下面的cas改成SIGNAL(-1)    int ws = pred.waitStatus;    if (ws == Node.SIGNAL)        // 如果已经是-1，表示后继节点可以安心睡觉了，前节点锁释放后会唤醒后继节点        return true;    if (ws > 0) {      // ws大于1表示节点状态已经取消了，可以跳过该节点了        do {        // 比较难看懂，从后往前看，pred = pred.prev表示前节点指到再前一个节点；            // node.prev = pred当前node节点的前节点指向刚刚的pred。加上后面那句pred.next = node;             // 其实就是删除中间的取消节点。            node.prev = pred = pred.prev;        } while (pred.waitStatus > 0);        pred.next = node;    } else {        // 将waitStatue cas成signal状态        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);    }    return false;}
// 继续看，shouldParkAfterFailedAcquire调用后，最终会返回true，紧接着调用parkAndCheckInterrupt()，进入睡眠状态private final boolean parkAndCheckInterrupt() {  // 进入awit，正常唤醒LockSupport.unpark(线程)    LockSupport.park(this);     // 是否是中断返回    return Thread.interrupted(); }

// java.util.concurrent.locks.ReentrantLock
public void unlock() {    // 核心方法调用，进行锁释放    sync.release(1); }

// java.util.concurrent.locks.AbstractQueuedSynchronizer
public final boolean release(int arg) {    // 尝试释放锁，由AQS子类ReentrantLock实现    if (tryRelease(arg)) {         Node h = head;        if (h != null && h.waitStatus != 0)            unparkSuccessor(h); // 唤醒h节点线程        return true;    }    return false;}

// java.util.concurrent.locks.ReentrantLock#Sync
protected final boolean tryRelease(int releases) {    // 减后得到目前还被锁定的资源    int c = getState() - releases;    // 如果当前线程不是队列锁持有者，抛异常    if (Thread.currentThread() != getExclusiveOwnerThread())        throw new IllegalMonitorStateException();    boolean free = false;    if (c == 0) {        free = true;      // 如果没有锁了，队列锁持有者置空        setExclusiveOwnerThread(null);    }    // 不用cas更新状态，会成功，因为当前线程是持有排它锁的    setState(c);    return free;}

// java.util.concurrent.locks.AbstractQueuedSynchronizer
private void unparkSuccessor(Node node) {    int ws = node.waitStatus;    if (ws < 0)        // 更新为0，进行复位        compareAndSetWaitStatus(node, ws, 0);
    // 注意：获取头节点的下一个节点进行唤醒的，因为头节点是持有锁的节点。    Node s = node.next;  // s.waitStatus表示已经被取消了，会循环从后到前，找到第一个等待中的线程节点    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)      // 进行唤醒（此处，是唤醒了线程2的）        LockSupport.unpark(s.thread);}

// java.util.concurrent.locks.AbstractQueuedSynchronizer
final boolean acquireQueued(final Node node, int arg) {    boolean failed = true;    try {      // 中断标识，但不会抛异常        boolean interrupted = false;        for (;;) {             // 循环，被唤醒后会继续进入循环，就可以通过调用tryAcquire(arg)成功了，将当前节点更新为头节点，并释放前节点帮助GC            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);    }}// 至此，唤醒的线程2，获取锁成功，可以执行任务了。