由ReentrantLock的非公平锁简画流程和源码分析了解AQS

AQS:AbstractQueuedSynchronizer, 队列同步器，它是Java并发用来构建锁和其他同步组件的基础框架
官方文档：提供一个框架，用于实现依赖先进先出（FIFO）等待队列的阻塞锁和相关同步器（信号量，事件等）。 该类被设计为大多数类型的同步器的有用依据，这些同步器依赖于单个原子int值来表示状态。主要是通过维护一个state 变量以及用来存放阻塞线程的双向队列来控制同步

state 0代表释放，1或者>1(锁重入)代表被占有，

从ReentrantLock的非公平锁的lock实现来看AQS：

一开始没想写源码分析，总感觉少点什么，补上之后，结合流程图和AQS队列流程还是比较容易理解的，请耐心看源码分析的注释

 

对着源码看更容易理解，难于理解的在于对AQS双向队列的操作：

AQS双向队列操作：假设ABC三个线程，A先获取到锁

锁释放：

ReentrantLock源码分析：

  //非公平锁NonfairSync
  static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        //lock入口
        final void lock() {
  
             //CAS 直接去获取锁，尝试修改state 0变为1。修改成功则获取锁成功。
             //这里用CAS 修改成功返回true，修改失败说明state已经不是0，被其他线程抢先修改了，返           
             //回false
            if (compareAndSetState(0, 1))
                //成功获取锁，设置持有锁的线程为自己也就是当前线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //CAS获取所失败，再次尝试获取锁，如果锁已经释放，这步就会有很大的性能提高
                //这里是父类的抽象，子类实现就是下面的tryAcquire
                acquire(1);
        }
        //非公平锁尝试获取锁
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

下面看CAS获取锁失败的逻辑，进入acauire(1): 

//AQS尝试获取锁
 public final void acquire(int arg) {
           //tryAcquire需看子类的具体实现，这里看的是NonfairSync的tryAcquire
           //实现nonfairTryAcquire
        if (!tryAcquire(arg) &&
             //尝试获取所失败，会为当前线程建立线程节点放入队列尾走addWaiter(Node.EXCLUSIVE)
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            
           //中断补偿
            selfInterrupt();
    }
 //NonfairSync的tryAcquire实现
 //尝试获取锁，true获取锁成功，false失败
 final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            //state=0可以进行获取锁
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    //CAS成功获取锁，设置持有锁的线程为当前线程
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //c!=0说明锁已经被持有，判断是已经持有锁的线程，（可重入）
            else if (current == getExclusiveOwnerThread()) {
                //可重入锁 state+1
                int nextc = c + acquires;
                //加1之后小于0,state值不对抛出异常
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                //可重入锁加1后赋值
                setState(nextc);
                return true;
            }
            return false;
        }


  //新建线程节点，mode以给定模式构造结点，有两种：EXCLUSIVE（独占）和SHARED（共享）这里是独占
  //ReentrantLock为独占锁
  private Node addWaiter(Node mode) {
        //为当前线程建立节点，独占模式，当前线程也就是刚刚来尝试获取锁失败的线程
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        //这里想把新建的节点放入队尾，所以当前队尾的next 应指向新建的节点
        Node pred = tail;
        //当前队尾不为空，就是说当前队列里有没有其他线程节点在等待
        if (pred != null) {
            //新建节点的前置指向当前队尾节点，
            //这里就像流程图里，放入C线程节点的时候，C的前置指向B
            node.prev = pred;
            //然后CAS更新尾巴节点为新建节点
            if (compareAndSetTail(pred, node)) {
                //更新成功，把队列的当前队尾节点的下一个节点指向新建节点
                //因为是双向队列，要改变或确定一个节点的位置 就要指定节点的prev和next
                //就是我在你后面，我的前面是你，你的候面是我，才能确定我在你后面
                //这里有个问题，因为分三步操作：1 修改新建节点的前置。2 CAS修改尾巴节点tail
                //3 修改新建节点的前置节点的后置，三步操作不是原子操作，思考点，有可能我
                //的前置节点修改好了，但是我的前置节点的后置却是null--就是我知道我前面是你，
                //你不知道你后面是我                        
                pred.next = node;
                //返回新建节点
                return node;
            }
        }
        //这里如果尾巴节点为null,说明目前还没有线程节点在队列里，需初始化头节点，并把新建节点
        //放在头节点的候面
        //这里可以看流程图的，B线程节点入队的时候，
        enq(node);
        return node;
    }

  //初始化头节点，并把新建的线程节点放入头节点候面。可看流程图B节点入队的时候
  private Node enq(final Node node) {
        //这个是死循环直到新建节点放入队列尾成功，跳出循环
        for (;;) {
            //再次判断尾巴节点是不是空，因为可能中途被其他线程新建了
            Node t = tail;
            if (t == null) { // Must initialize
                 //CAS创建头节点
                if (compareAndSetHead(new Node()))
                    //初始化头节点也是尾巴节点
                    tail = head;
            }
            //头节点被初始化之后，下次循环走这个
            else {
                //这块和头节点不为空的操作是一样的，新建节点的前置指向尾巴节点
                node.prev = t;
                //CAS 更新尾巴节点为新建节点
                if (compareAndSetTail(t, node)) {
                    //原来的尾巴节点的后置指向新建节点
                    t.next = node;
                    //返回新建节点
                    return t;
                }
            }
        }
    }

新建节点放入队尾之后，看接下来的操作，分析acquireQueued方法，这个方法是我认为不太好理解的地方，包括线程自旋获取锁，

获取失败之后标记前置节点的waitStatus为SIGNAL，然后自身park 停止自旋,前置节点释放掉锁之后，unpark唤醒后置最近的有效节点(实际处理起来并不像说的那么简单)，看Doug Lea大师怎么处理的：

//新入队列的节点都会走这一步，从流程图线程B节点入队来分析 
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            //死循环也就是自旋，这里每个节点至少自旋一次去获取锁，获取失败后线程走else,会让线程            
            //park，park后就不再自旋了，等待unpark唤醒
            for (;;) {
                //获取新建节点的前置
                final Node p = node.predecessor();
                //如果新建节点的前置为头节点，那么新建节点会再次尝试获取锁
                //如果此时锁被释放，成功获取锁，
                if (p == head && tryAcquire(arg)) {
                   //设置新的头节点为新建节点，
                   //流程图的B线程节点成功获取锁，头节点被放弃，
                   //新的头节点为B
                    setHead(node);
                    //让原来的头节点指向为null ,GC会回收掉。头节点prev本身就是null
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //1.如果说B线程节点获取锁失败
                //2.或者说新建节点的前置不是头节点，可看流程图线程C线程节点入队，他的前置
                //节点是B节点
                //如果获得锁失败，根据waitStatus决定是否park线程
                if (shouldParkAfterFailedAcquire(p, node) &&
                    //前面执行为true会执行这一步park线程，等待unpark唤醒后，
                    //检查线程节点线程是否被中断，被中断则返回true
                    //如果被中断过，阻塞中的线程并不会响应中断，回到acquire()看到
                    //selfInterrupt() 补偿中断
                    parkAndCheckInterrupt())
                                             
                    interrupted = true;
            }
        } finally {
            //抛出异常，取消节点操作，出队操作，这块没啥好说的
            if (failed)
                cancelAcquire(node);
        }
    }

 //主要把当前节点的前置节点waitStatus标记为SIGNAL，释放锁后好唤醒当前节点
 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        //如果为SIGNAL也就是-1 说明已经被标记过，直接返回
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        //waitStatus>0说明前置节点是已经撤销无效的节点，跳过
        //拿流程图的BC来说明，BC都在等待，然后突然B不想等待了，撤销了，那么由谁来唤醒C，
        //C就往前继续找有效的前置节点，找到了头节点
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } 
        //这里如果waitStatus没有被修改过,waitStatus默认为0
        //或者说小于0又不是SIGNAL，也就只有PROPAGATE
        //PROPAGATE在共享锁以及condition队列里使用，这里不做介绍
        else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            //CAS 更改前置节点的waitStatus为SIGNAL，这样前置节点释放锁后会唤醒当前节点node
            //这里就会发现，从AQS队列操作流程图来看，B节点把A节点的waitStatus置为SIGNAL，
            //C节点把B节点的waitStatus置为SIGNAL，这样A节点释放锁，会唤醒B，B执行完释放锁会
            //唤醒C
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

加锁到这里就结束了。下面看锁的释放，锁释放比较简单：

 //释放锁
 public final boolean release(int arg) {
        if (tryRelease(arg)) {
          
            Node h = head;
            //成功释放锁后，判断队列中是否有需要唤醒的线程节点
            if (h != null && h.waitStatus != 0)
                //唤醒下一个有效节点
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

 //子类实现，尝试释放锁
 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);
            }
            //更新state ，这里如果state =0释放锁成功，如果不等于0，
            //还有资源没释放（可重入锁机制）
            setState(c);
            return free;
        }

   //唤醒节点
   private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        
        if (ws < 0)
            //这里的ws 一般是-1
            //修改当前节点的waitStatus为0就是我可以唤醒别人了
            compareAndSetWaitStatus(node, ws, 0);

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        Node s = node.next;
        //当前节点后置没有节点或者节点无效
        if (s == null || s.waitStatus > 0) {
            s = null;
            //从队列尾部往前遍历寻找当前节点最近的有效节点
            //这里为什么从后往前遍历，因为在加锁的时候，新建节点的时候那个思考？
            //回到addWaiter看，三步不是原子操作。有可能头节点的next节点为空。但是其实已经存在了
            //只是还没有做pred.next = node这一步，所以从后往前遍历一定会遍历到所以节点                   
            for (Node t = tail; t != null && t != node; t = t.prev)
                //找到唤醒的节点t
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            //唤醒s线程继续可以自旋争夺锁
            LockSupport.unpark(s.thread);
    }

到这里就结束了：分析过程中遇到几个问题。查了很多：park 使当前线程取消自旋（即使在死循环里），一开始对为什么释放锁的时候寻找后置节点从后遍历有疑问，因为感觉从前遍历一下不就找到了吗，分析完之后发现了原因。

这里再说下简述下公平锁吧，公平锁和非公平锁不同就是，公平锁不会直接CAS获取锁，而是先去队列里判断有没有等待的线程，如果有等待的线程，那么直接排在候面，如果只有头节点或者没有等待的线程他会尝试获取锁，主要看hasQueuedPredecessors这个方法，其他的都和公平锁一样了

AQS里面使用了大量的CAS和unsafe类的方法，有兴趣可以了解一下，底层C++实现的

AQS的静态内部类Node 也可以具体了解下

AQS里还有很多没分析到，有在像Semaphore，CountDownLatch里面用到的，后续再去学习，关于AQS 网上太多文章了，我这里就当作自己的一次学习笔记吧