【并发编程】AQS源码分析(一) 从ReentrantLock来看AQS的基本数据结构和主要执行流程

在并发编程中AQS属于必知必会的内容了。AQS全称 AbstractQueuedSynchronizer抽象队列同步器。"抽象"就可以看出他是一个抽象类，我们在用时需要对他进行重写来自定义我们自己的同步器。

看懂这个源码个人认为需要一点链表操作的基础，不然容易晕。

类结构图

图简单解析

ReentrantLock 锁内部：

1、Sync类是ReentrantLock的内部类，其继承了AQS

2、FairSync和NonFairSync也是ReentrantLock的内部类，继承了Sync,

3、FairSync实现了公平锁，NonFairSync实现了非公平锁

ReentrantLock公平锁和非公平锁

	//默认使用非公平锁
	ReentrantLock reentrantLock = new ReentrantLock(); 
	//如下构造方法:
	 public ReentrantLock() {
        sync = new NonfairSync();
    }


    //可以指定参数为公平还是非公平锁 true代表公平，false非公平
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }


	//当调用lock方法时,ReentrantLock类会根据具体的参数来指定调用公平锁
    //还是非公平锁的lock方法
	public void lock() {
        sync.lock();
    }

AbstractQueuedSynchronizer类：

1、Node类是一个双向链表，是AQS中的阻塞队列,当线程获取不到锁时，
会将自己封装成一个Node节点加入到阻塞队列中。

2、Node中包括了链表的前后节点pre，next，Node代表的当前线程thread，
以及当前线程的状态waitStaus

3、在AQS类中声明了一些变量：
	state = 0 时表示没有线程获取锁
	state = 1 时表示有线程已经获取了锁 

4、AQS中还有一些抽象的方法，需要子类去重写的。

AQS类信息

	//阻塞队列的头节点，也是当前拥有锁的线程
  	private transient volatile Node head;

	//阻塞队列的尾节点
    private transient volatile Node tail;

 	//锁同步状态 0 代表没有线程拥有锁，1代表有线程已经拥有锁
 	//锁重入导致state可以 > 1
    private volatile int state;
    
    //节点信息，具体内容看下面
	static final class Node{}

Node信息

	//共享模式的节点，本篇文章不涉及
	    static final Node SHARED = new Node();
        //独占模式
        static final Node EXCLUSIVE = null;

       	//waitStatus状态之一：线程 取消 ，不再获取锁
        static final int CANCELLED =  1;
        
       //waitStatus状态之一 : 表示当前线程可以被前一个节点的线程唤醒，
       //记住这唤醒是由阻塞队列中前一个节点来唤醒后一个节点的线程的
        static final int SIGNAL    = -1;
        
       //waitStatus状态之一  ：条件队列的状态，这篇不涉及
        static final int CONDITION = -2;
     	
     	//waitStatus状态之一 ：先不涉及
        static final int PROPAGATE = -3;
		
		//节点中线程等待的状态
		volatile int waitStatus;
		//前一个节点
        volatile Node prev;
		//后一个节点
        volatile Node next;

     	//当前节点锁代表的线程
        volatile Thread thread;

   		//条件队列中的等待线程，这里先不涉及
        Node nextWaiter;

这篇文章先主要介绍加锁和解锁过程，关于条件队列的一些内容先不涉及。

加锁过程源码

这里以公平锁举例：

//当我们调用lock方法时
	final void lock() {
			//这里调用了AQS类中的acquire方法
            acquire(1);
     }

 //接下来调用了acquire方法
 public final void acquire(int arg) {
			/**
				1、tryAcquire方法时需要自己重写的方法，
				也就是FairSync实现的，目的是为了先去尝试获取锁
				即将state试图修改为1，如果这里就返回true，即获取到锁了，
				那么就不会继续往下执行了。
				
				2、如果没有获取到锁，则只需执行	
				acquireQueued		 			   	  
				(addWaiter(Node.EXCLUSIVE), arg) 方法
				目的是将当前线程包装成一个Node节点加入到阻塞队列中
				并将当前线程挂起
				
			**/
	        if (!tryAcquire(arg) &&
	            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
	            selfInterrupt();
	    }

	//先执行tryAcquire 方法
  protected final boolean tryAcquire(int acquires) {
  			//获取当前线程
            final Thread current = Thread.currentThread();
            int c = getState();
            
            // c == 0 说明当前没有线程获取锁
            if (c == 0) {
            	/**因为是公平锁，所以要讲究先来后到
            		1、hasQueuedPredecessors()方法要判断一下阻塞队列中、
            		是否已经由其他线程再排队了
            		2、如果没有线程排队则直接执行
            		compareAndSetState(0, acquires) 来试图获取锁
            	**/
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    //如果获取锁成功，要将当前线程标记为独占锁
                    setExclusiveOwnerThread(current);
                    //返回true
                    return true;
                }
            }
            //如果c ！= 0 要判断当前拥有锁的线程是不是自己
            //这里为了实现重入锁
            else if (current == getExclusiveOwnerThread()) {
            	//如果是自己的话，让state值 + 1
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                //state 赋值
                setState(nextc);
				//获取锁成功，返回true
                return true;
            }
            /**否则，获取锁失败，返回false，返回false后需要继续返回到
            acquire方法继续执行
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
            **/
            return false;
        }

当返回执行acquire方法时，先要执行addWaiter(Node.EXCLUSIVE)方法，将节点加入到阻塞队列中。如下：

	//将当前线程封装成Node加入到阻塞队列中
   private Node addWaiter(Node mode) {
   		//封装成node节点，waitStats默认值为0
        Node node = new Node(Thread.currentThread(), mode);
        //将pred节点执行尾节点
		//这里千万不要迷惑，这里pred只是定义了一个临时变量
        Node pred = tail;
        //如果尾节点不为null
        if (pred != null) {
        	//将当前节点的prev节点设置为pred节点
        	//即当前节点的前一个节点设置为原来的尾节点
        	//此时当前节点将会作为尾节点
            node.prev = pred;
            //通过CAS操作将tail节点替换为当前节点
            if (compareAndSetTail(pred, node)) {
            	//替换成功后，将原来尾节点的next节点指向当前节点
            	//这样就完成了入队操作
                pred.next = node;
                //返回当前节点
                return node;
            }
        }
		/**
		如果pred节点为null，说明链表是空的，阻塞队列为空、
		或者CAS设置尾节点失败，会执行到这里
		enq方法就是采用自旋的方法将node节点入队
		**/
        enq(node);
        return node;
    }

 //采用自旋的方式将Node节点加入到阻塞队列中
 private Node enq(final Node node) {
 		//自旋不断的循环尝试
        for (;;) {
            Node t = tail;
            //如果队列为空，tail为null时
            if (t == null) { // Must initialize
            	//要先将head进行初始化，通过CAS设置头结点head
                if (compareAndSetHead(new Node()))
                	//如果设置head成功，将tail指向head
                    tail = head;
            } else {
            	//如果t不为null，将当前节点node的prev节点设为t
            	//（试图将node设置为阻塞队列的对尾）
                node.prev = t;
                //通过CAS设置tail节点
                if (compareAndSetTail(t, node)) {
                	//设置tail成功后，将t的next设置为node
                    t.next = node;
                    return t;
                }
                //如果失败继续循环尝试
            }
        }
    }

//将当前节点加入到阻塞队列后，要根据队列中节点的状态进行判断是否要
//进行挂起当前线程，true表示要挂起，false不挂起，正常应该返回false
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
        	//是否需要挂起，否
            boolean interrupted = false;
            //自旋判断是否要挂起当前线程
            for (;;) {
            	//当前节点的前一个节点
                final Node p = node.predecessor();
                //如果当前节点是head之后的第一个节点，那么尝试去获取锁
                if (p == head && tryAcquire(arg)) {
                	//如果获取锁成功，则将当前节点设置为head
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    //返回false，不挂起
                    return interrupted;
                }
                /**如果不符合上面的条件
                1.node不是队列中第一个节点，2.尝试获取锁失败
                则判断是否要挂起当前线程
                当挂起线程时，要等待前一个节点唤醒后一个节点，唤醒时，
                要接着当前位置的代码继续循环获取锁(这里是自旋不断的循环)
                **/
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
        	//当发生异常时
            if (failed)
            	//将当前节点标记为cancle状态
                cancelAcquire(node);
        }
    }

//当跟head节点竞争获取锁失败时，要根据前一个节点的状态判断是否要挂起当前线程
//true 挂起，false不挂起
private static boolean shouldParkAfterFailedAcquire(Node pred,
 Node node) {
		//前一个节点的状态
        int ws = pred.waitStatus;
        //如果前一个节点状态为 SIGNAL = -1 时
        if (ws == Node.SIGNAL)
            /*
             * 要挂起当前线程
             */
            return true;
		//如果前一个节点的状态>0 只有取消状态为1 
        if (ws > 0) {
            /*
             *从当前节点开始向前寻找，直到前一个节点的状态<= 0 为止
             将 < = 0 的节点作为当前节点的前一个节点
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             *状态为 0 或 -2， -3
             	这个时候将前一个节点状态设置为SIGNAL,
             	表示当前节点可以被唤醒状态
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        //如果不是SIGNAL，则返回不挂起
        return false;
    }

   /**
   	* 如果shouldParkAfterFailedAcquire 返回true表示线程在挂起过程中被中断了
   	* 则执行此方法挂起当前线程
   **/
  private final boolean parkAndCheckInterrupt() {
   		//挂起线程
        LockSupport.park(this);
        return Thread.interrupted();
    }

//标记节点取消的方法
 private void cancelAcquire(Node node) {
        // Ignore if node doesn't exist
        if (node == null)
            return;

        node.thread = null;

        // 将当前节点的前一个节点指向最近一个节点状态 < =0 的节点
        //跳过前面所有取消的节点
        Node pred = node.prev;
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;

        // 标记当前节点前一个节点的下一个节点
        Node predNext = pred.next;

        // 将当前节点的状态设置为canceled
        node.waitStatus = Node.CANCELLED;

        
        //这里是要做出队操作
        // 如果当前节点是尾节点，那么将当前节点的前一个节点设置为尾节点
        if (node == tail && compareAndSetTail(node, pred)) {
        	//将前一个节点的next节点设置为null
            compareAndSetNext(pred, predNext, null);
        } else {
           
            int ws;
            //如果node不是tail也不是head后的第一个节点，而是一个中间的节点
           
            if (pred != head &&
             //并且前一个节点是可唤醒状态(如果不是 -1，只要<0 就设置为-1)
                ((ws = pred.waitStatus) == Node.SIGNAL ||
                 (ws <= 0 && compareAndSetWaitStatus(pred, 
                 ws, Node.SIGNAL))) &&
                pred.thread != null) {
                //将node节点出队，将前一个节点的next指向当前node节点的next
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);
            } else {
            	//当node为head的下一个节点时，进行出队并唤醒
                unparkSuccessor(node);
            }
            node.next = node; // help GC
        }
    }

//走到此方法，说明当前线程要取消了
//当前节点的线程为head节点之后的第一个节点时，
//对node节点进行出队，并唤醒后继节点
 private void unparkSuccessor(Node node) {
       
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        /*
         *对node节点进行出队，从后往前遍历找到最近next节点 < = 0 
         的节点作为next
         */
        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);
    }

至此，加锁过程的代码基本上就结束了。
画张图总结一下整个过程吧。更清晰一点。

解锁过程

接下来是解锁过程，这个比较简单，每次解锁都要让state -1，因为有重入，所以要判断最终state是否为0

public void unlock() {
 		//调用AQS中的release方法
        sync.release(1);
    }

//AQS类中的释放锁方法
 public final boolean release(int arg) {
 		//tryRelease为Sync中重写的方法
        if (tryRelease(arg)) {
        	//如果释放成功了
            Node h = head;
            //头节点不为null，并且状态不为0
            //这里为啥是不为0呢？我自己的理解是当唤醒时，可以
            //去查看unparkSuccessor方法，会将node状态设置为0
            //所以在唤醒前要不为0
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

//回到Sync类中看tryRelease方法
protected final boolean tryRelease(int releases) {
			//释放锁时，每次 state -1
            int c = getState() - releases;
            //释放的锁必须是当前线程拥有的锁才可以释放
            if (Thread.currentThread() != 
            getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            //如果c已经为0了，说明已经不持有锁了
            if (c == 0) {
                free = true;
                //将独占锁当前线程设为null
                setExclusiveOwnerThread(null);
            }
            //如果c！=0
            //给c赋值
            setState(c);
            return free; //返回释放释放
        }

好了AQS中加锁和解锁过程基本上就已经介绍完了。

总结

回头看看总觉得还是有点乱了。来个小结吧

1、在加锁和解锁过程中用到CAS的四个地方

• 尝试获取锁更新state状态时 tryAcquire :compareAndSetState
• 向阻塞队列添加节点时 addWaiter : compareAndSetTail
• 根据前驱节点判断是否要挂起当前线程时设置前驱节点的状态:compareAndSetWaitStatus
• 当发生异常取消当前节点时，当前节点出队时 compareAndSetNext

2、用到自旋的两个地方:

• 自旋将node节点设置为tail
• 自旋成为head节点之后的第一个节点去竞争获取锁