JUC核心类AQS分析学习

 首先是在AbstractQueuedSynchronizer当中很重要的对象Node:

static final class Node {
        //共享锁标识
        static final Node SHARED = new Node();
        //独占锁标识
        static final Node EXCLUSIVE = null;

        //等待状态
        //取消状态
        static final int CANCELLED =  1;
        //后续节点处于等待状态
        static final int SIGNAL    = -1;
        //等待队列状态
        static final int CONDITION = -2;
        //共享模式，同步状态的获取的可传播状态
        static final int PROPAGATE = -3;

         //本节点的等待状态
        volatile int waitStatus;
        //前节点
        volatile Node prev;
        //下个节点
        volatile Node next;
        //该节点的线程
        volatile Thread thread;
        //同步队列节点,也可以作为Condition的等待队列节点
        Node nextWaiter;

        //上个节点
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
}

以及AbstractQueuedSynchronizer中的其他成员变量：

//头节点
private transient volatile Node head;
//尾节点
private transient volatile Node tail;
//同步状态
private volatile int state;

CAS操作同步状态的方法：

 protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

插入节点方法，该链表是在尾部拆入节点

private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) {
                 //尾为空，说明链表尚未创建，cas设置头，然后尾部也指向头节部指向的节点
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                //之前的尾节点成为插入的节点的前节点
                node.prev = t;
                //cas 设置当前节点为尾节点
                if (compareAndSetTail(t, node)) {
                    //上任尾节点的洗个节点指向插入的节点
                    t.next = node;
                    //返回前节点
                    return t;
                }
            }
        }
    }

设想一种并发的场景，当多个线程同时竞争且节点链未初始化

1.线程1判断尾节点为空，线程让出执行

2.线程2进来也判断尾节点为空，然后初始化了头尾节点，因为方法中for (;;) {}代码块的原因，并没有退出方法，继续执行

3.线程1此时开始继续执行，此时线程1也去设置头尾节点，但是cas操作发现需要更改的对象与跟预期的不一致，无法执行成功，返回false,本次for循环结束，准备下次循环（头尾操作方法如下）

//这两个方法只会被插入节点的方法调用
private final boolean compareAndSetHead(Node update) {
        return unsafe.compareAndSwapObject(this, headOffset, null, update);
    }

private final boolean compareAndSetTail(Node expect, Node update) {
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }

4.此时线程1进入下次循环，尾节点本次不为空，将进入else的插入节点的流程，线程2即是如此

 

addWaiter

增加一个排队节点并制定模式 

也就是上文代码中的

static final Node SHARED = new Node();
static final Node EXCLUSIVE = null;

分别为共享模式和独占模式

private Node addWaiter(Node mode) {
    //创建节点
    Node node = new Node(Thread.currentThread(), mode);
    //先尝试快速插入
    Node pred = tail;
    if (pred != null) {
        //快速插入
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //插入
    enq(node);
    return node;
}

unparkSuccessor 唤醒后续节点

private void unparkSuccessor(Node node) {
        //设置本节点的等待状态为0
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        //获取下个节点
        Node s = node.next;
        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)
        //unpark获取到的节点中的线程
            LockSupport.unpark(s.thread);
    }

其中值得注意的是唤醒下个线程是从队位开始遍历

为什么从队尾开始遍历

可以从enq方法中看出端倪

                

        for (;;) {
                ①node.prev = t;
                ②if (compareAndSetTail(t, node)) {
                ③ t.next = node;
                   return t;
               }

        }

首先设置的插入节点的前置节点为队列中的尾节点，注意 在此处是可能出现线程安全问题的，不同线程在②步骤之前都可以将插入的节点前置节点指向之前的尾节点。但是在第二个步骤cas设置值的过程并不能成功，将会进入下一次for循环，直到读取到正确并设置尾节点。

并且在②中只是原子性的设置了尾节点，在if代码块中并不是线程安全的，该线程执行到2的地方时，并未指定之前的尾节点的下个节点，所以此时如果unparkSuccessor方法是按头到尾的遍历方式来获取下个节点的话,就会出现节点丢失的问题。

 

private void cancelAcquire(Node node) {
    //节点为空 忽略
    if (node == null)
        return;

    node.thread = null;

    //找到node前置节点中状态不是取消状态的节点，并将Node的前置节点设为该节点
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;
    
    Node predNext = pred.next;

    //设置节点等待状态为取消
    node.waitStatus = Node.CANCELLED;

    //是尾节点 移除自己 设置前节点的下节点为null
    if (node == tail && compareAndSetTail(node, pred)) {
        compareAndSetNext(pred, predNext, null);
    } else {
        int ws;
        if (pred != head && //前置节点不是头节点
            ((ws = pred.waitStatus) == Node.SIGNAL ||    
                //如果前置节点小于为初始值0，设置前置节点的状态为后置等待状态
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            //前节点中线程不为null
            pred.thread != null) {
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                //上节点的下个节点指向本节点下个节点
                compareAndSetNext(pred, predNext, next);
        } else {
            //unpark node的下一个节点
            unparkSuccessor(node);
        }

        node.next = node; 
    }
}

 shouldParkAfterFailedAcquire ：

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
       //前置节点为 Node.SIGNAL 状态，即当前节点本来就应等待
        return true;
    if (ws > 0) {
        // 前置节点为取消状态，将节点的前置节点指向前置链中不是取消状态的节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        //设置前节点的等待标识为 Node.SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

acquireQueued：

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; 
                failed = false;
                return interrupted;
            }
            //如果该节点本该等待 就让线程标志挂起
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            //失败取消获取锁
            cancelAcquire(node);
    }
}

---

让我们完整分析尝试获取锁的过程