AbstractQueuedSynchronizer源码阅读与理解

AbstractQueuedSynchronizer源码阅读和理解
简述：这个抽象类是J.U.C的锁同步的基础框架（简称：AQS），与之相关的锁同步实现类有：ReentrantLock、ReentrantReadWriteLock、Semaphore、CountDownLatch、FutureTask……这个类使用CLH队列，让我们来一探究竟。

tips：所谓CLH锁是并行计算中自旋锁的实现机制之一。
自旋的含义是如果一个Atomic寄存器的值不符合要求，就一直进行循环。这与阻塞的区别是：阻塞会产生现场恢复的开销，而自旋锁省却了这一部分，同时自旋锁需要一直占用CPU。

几个属性：

//头节点，记录的是当前正在运行的节点或者NULL
private transient volatile Node head;
//尾节点
private transient volatile Node tail;
//锁的状态，在互斥锁中它表示着线程是否已经获取了锁，0未获取，1已经获取了，大于1表示重入数。
private volatile int state;
//节点类
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;
    //此节点的线程是处在一个条件队列中并不会被唤醒，只有当状态为0的时候才能被唤醒
    static final int CONDITION = -2;
    //传播节点
    static final int PROPAGATE = -3;
    //以上都是waitStatus的值，还有一个初始化0值；所以该值相当于当前线程的状态
    volatile int waitStatus;
    //前驱节点
    volatile Node prev;
    //后继节点
    volatile Node next;
    //该节点的线程
    volatile Thread thread;
    //下一个等待节点
    Node nextWaiter;
}

几个方法：

//分析一下独享锁上锁过程：
//acquire函数：获取独享锁的顶级入口！
public final void acquire(int arg) {
        if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
//acquire函数--》tryAcquire函数：获取锁的函数，受保护的方法，此框架实现类只需重写该方法，定义获取锁的方式即可。
protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }
//acquire函数--》addWaiter函数：获取锁失败则加入CLH队列中去等待唤醒。
private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;//获取尾巴节点
        if (pred != null) {//判断尾巴节点是否为空，一般都不为空吧
            node.prev = pred;//设置节点的前驱节点
            if (compareAndSetTail(pred, node)) {
                //CAS设置tail到当前节点
                pred.next = node;//设置后继节点为当前节点
                return node;
            }
        }
        //多线程插入失败则进入enq函数
        enq(node);
        return node;
    }
//addWaiter函数--》enq函数：For CAS插入队尾
private Node enq(final Node node) {
        //又是一个循环CAS操作
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }
//acquire函数--》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))//如果p==head说明当前节点是等待队列的第二个节点并尝试获取锁 {
                    //将当前设置为头节点
                    setHead(node);
                    //出列!把关联的下一个节点置空帮助垃圾回收
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
//找到安全的休息点休息并尝试拿锁
if(shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())
            interrupted = true;
            }
        } finally {
            //如果当前线程没拿到资源，发生了中断啥的
            if (failed)
                //取消获取锁
                cancelAcquire(node);
        }
    }

//上完锁，来看看独享锁释放锁过程：
//release函数：释放独享锁的顶级入口！根据tryRelease函数的返回值来判断是否释放成功。
public final boolean release(long arg) {
        if (tryRelease(arg)) {
            //获取头节点
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
}
//release函数--》tryRelease函数：释放锁的函数，受保护的方法，此框架实现类只需重写该方法，定义获取锁的方式即可。
protected boolean tryRelease(long arg) {
        throw new UnsupportedOperationException();
    }
//release函数--》unparkSuccessor函数：唤醒下一个等待线程，FIFO，即唤醒最后一个线程！
private void unparkSuccessor(Node 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;
            //拿到tail并唤醒
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        //唤醒！
        if (s != null)
            LockSupport.unpark(s.thread);
    }


//tips:该抽象类中还使用了LockSupport类（阻塞原语），来阻塞线程和唤醒线程

小结：AQS框架维护好了如何入队和出队，至于如何获取锁还需具体的实现类去定义，具体操作是，重写tryRelease和tryAcquire两个方法。

接下来我们看看，AQS框架里面的ConditionObject类：

public class ConditionObject implements Condition, java.io.Serializable {
        private static final long serialVersionUID = 1173984872572414699L;
几个变量：
        /** First node of condition queue. */
        //维护一个队列的头节点
        private transient Node firstWaiter;
        /** Last node of condition queue. */
        //尾节点
        private transient Node lastWaiter;

        /**
         * Creates a new {@code ConditionObject} instance.
         */
        public ConditionObject() { }

内置几个方法：
//让线程进入挂起状态，await函数是可响应中断的，还有其他的挂起方法，awaitUninterruptibly函数不响应中断，awaitNanos限时等
    public final void await() throws InterruptedException {
    //判断线程是否被中断
            if (Thread.interrupted())
                throw new InterruptedException();
            //加入等待队列
            Node node = addConditionWaiter();
            //释放当前线程持有的锁并返回线程的state上文有说明
            int savedState = fullyRelease(node);
            //线程中断标记
            int interruptMode = 0;
            //循环判断该节点是否加入了AQS队列中
            while (!isOnSyncQueue(node)) {
                //不给线程通行证
                LockSupport.park(this);
                //循环判断是否被中断
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            //一旦被加入AQS队列中则，开始竞争获取锁
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            //清理不是在等待的节点
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            //如果出现中断则抛出异常
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

//唤醒等待队列头
public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

}
//唤醒等待队列所有
public final void signalAll() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignalAll(first);
        }