java 并发包-AbstractQueuedSynchronizer

简介

AbstractQueuedSynchronizer 就是我们常说的AQS-同步器。常用的有ReentrantLock、ReadWriteLock、CountDownLatch，内部实现都依赖AQS类，可以说AQS是实现同比必备良药。

源码分析

AQS的主要参数 state字段 表示同步的状态，需要通过传入值与state进行比较是否一致。CountDownLatch就是通过state来控制达到阻塞目的，当为0的时候，释放。

//等待队列的头节点 private transient volatile Node head; //等待队列的尾节点 private transient volatile Node tail; //同步状态 private volatile int state;

AQS内部通过FIFO队列实现排队获取资源，通过Node的waitStatus来控制节点的状态，再由状态判断资源是否应该被该线程获取，

 static final class Node {        static final Node SHARED = new Node();        static final Node EXCLUSIVE = null;       //取消状态 被打断或者超时，相当于该节点被废了        static final int CANCELLED =  1;      //等待触发状态 当unpart时，只有被unpark才能释放        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;        .....   }

获取锁资源

acquire方法是AQS提供对外占用资源的接口
1 首先调用子类重写tryAcquire方法，资源已被占用，则添加节点入队

   public final void acquire(int arg) {        if (!tryAcquire(arg) &&            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))            selfInterrupt();    }

入队主要通过自旋的方式、cas安全的将节点放至队列中

    private Node enq(final Node node) {        //自旋        for (;;) {            Node t = tail;            //尾节点为空，说明队列是空的 则赋值头部、尾部都为该节点            if (t == null) {                if (compareAndSetHead(new Node()))                    tail = head;            } else {                //将上一个节点设置为当前尾节点                node.prev = t;                //cas设置尾节点为改node 并且在设置原为节点的next指向当前node                if (compareAndSetTail(t, node)) {                    t.next = node;                    return t;                }            }        }    }    //添加等待节点    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方法，自旋直至设置成功        enq(node);        return node;    }

对当前节点进行自旋判断
1 当前节点的perv是否为头节点，如果是 这说明当前节点时排第一个的
2 再次尝试对比state是否满足当前值
1，2条件都满足，则返回
否则 往下走

  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; // help GC                    failed = false;                    return interrupted;                }                //不满足                if (shouldParkAfterFailedAcquire(p, node) &&                    parkAndCheckInterrupt())                    interrupted = true;            }        } finally {            if (failed)                cancelAcquire(node);        }    }

这一步主要是对等待状态进行判断
1 SIGNAL 时 直接返回true 则挂起等待被唤醒
2 >0 表示取消 则删除该节点
3 修改pred值为Node.SIGNAL 那么因为是自旋的原因，下一次有可能就是执行1步骤进行挂起操作

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {        int ws = pred.waitStatus;        if (ws == Node.SIGNAL)            return true;        if (ws > 0) {            do {                node.prev = pred = pred.prev;            } while (pred.waitStatus > 0);            pred.next = node;        } else {            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);        }        return false;    }

获取锁的过程就这样了。最后还需要说明的是，当被唤醒的时候，还要重新再次去竞争，然后循环上面的步骤，因为AQS获取锁是非公平的

释放锁

tryReleaseShared需要子类重写

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

1 如果head=tail 说明 队列空了，直接break
2 如果头节点的waitStatus为Node.SIGNAL 说明等待被唤醒
cas修改节点的waitStatus 成功 则 唤醒等待队列
3 继续自旋

  private void doReleaseShared() {        for (;;) {            Node h = head;            if (h != null && h != tail) {                int ws = h.waitStatus;                if (ws == Node.SIGNAL) {                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))                        continue;                               unparkSuccessor(h);                }                else if (ws == 0 &&                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))                    continue;                             }            if (h == head)                                    break;        }    }

unparkSuccessor 才是正真唤醒释放的地方
1 由于唤醒完之后，该节点将被释放，所以要保证改节点下的下一个节点时有意义的 不能为null或者被取消
2 LockSupport.unpark(s.thread); 唤醒线程

 private void unparkSuccessor(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;            for (Node t = tail; t != null && t != node; t = t.prev)                if (t.waitStatus <= 0)                    s = t;        }        if (s != null)            LockSupport.unpark(s.thread);    }

总结：AQS 使用cas进行安全竞争资源，如果未竞争到 则根据条件通过LockSupport.park对线程进行挂起。
如果某个线程释放资源时，则同理 通过 LockSupport.unpark唤醒线程加入竞争的行列。

各线程如果加入了node队列中，则通过FIFO公平竞争，但是毕竟是高并发的情况下，还没有加入node队列中的N个线程和node队列的第一个线程就会相互竞争资源，也就是说 获取锁是不公平的。