说明：本作者是文章的原创作者，转载请注明出处：本文地址：http://www.cnblogs.com/qm-article/p/7955781.html
一、AbstractQueuedSynchronizer介绍
AbstractQueuedSynchronizer(以下简称AQS)，它提供了一套完整的同步框架，比如常用的ReentrantLock、countdownLatch等一些类都继承了该抽像类，像之前博文中的线程池里也有它的是实现类，它的实现类如下
二、LockSupport
在分析AQS之前，先简单的了解下LockSupport这个类，先看看API文档的解释
先介绍这个类里的2个核心静态方法
1、park，使用LockSupport.park会阻塞当前线程，其作用类似于Object的wait方法。
2、unpark 该方法的的参数是Thread，使用LockSupport.unpark(thread)，会给thread线程一个许可证(也可以理解为通行证)，作用类似于notify方法
上述两个方法与Object的wait和notify类似，但也有不同之处，首先park和unpark不会抛异常，二、park与unpark的使用位置可以颠倒，这么说吧，我们在使用wait和notify，一般都是一个线程先wait，之后由notify去唤醒，然而park和unpark不一样，当某个线程执行park方法时，会查看有没有许可证，没有则阻塞，有则通，在执行unpark方法时，会向该参数的线程办法一个许可证，之后那个线程就拥有许可证，当遇到park方法时不会阻塞。当然如果某线程事先已经获取了许可证(即执行了unpark方法，参数为该线程)，那么当该线程再次执行park方法时却不会阻塞，下面看这个类的示例代码
1 public class TestLockSupport { 2 3 4 public static void main(String[] args) { 5 Thread threadA = new Thread(new Runnable() { 6 7 @Override 8 public void run() { 9 System.out.println("执行park方法前-------");//----1---- 10 //执行下面方法后threadA线程会阻塞 11 LockSupport.park(); 12 System.out.println("执行park方法后-------"); 13 } 14 }); 15 16 Thread threadB = new Thread(new Runnable() { 17 18 @Override 19 public void run() { 20 // TODO Auto-generated method stub 21 System.out.println("执行unpark方法前-------");//----2---- 22 //给threadA颁发一个许可证 23 LockSupport.unpark(threadA); 24 try { 25 Thread.sleep(1000);//这个作用是为了更好的演示 26 } catch (InterruptedException e) { 27 // TODO Auto-generated catch block 28 e.printStackTrace(); 29 } 30 System.out.println("执行unpark方法后-------"); 31 } 32 }); 33 34 threadA.start(); 35 threadB.start(); 36 } 37 }
执行结果如下(结果并不唯一）
执行park方法前——-
执行unpark方法前——-
执行park方法后——-
执行unpark方法后——-
值得注意的是，一个线程只能拥有一个许可证，简单的说就是当线程A内执行n(n>1)个park方法，你在线程B内也执行n个unpark(线程A)，按照正常理解，线程A内不会阻塞，但不巧的是，它阻塞了，示例代码如下
1 public static void main(String[] args) { 2 Thread threadA = new Thread(new Runnable() { 3 @Override 4 public void run() { 5 System.out.println("执行park方法前-------");//----1---- 6 LockSupport.park(); 7 LockSupport.park(); 8 System.out.println("执行park方法后-------"); 9 } 10 }); 11 12 Thread threadB = new Thread(new Runnable() { 13 14 @Override 15 public void run() { 16 // TODO Auto-generated method stub 17 System.out.println("执行unpark方法前-------");//----2---- 18 LockSupport.unpark(threadA); 19 LockSupport.unpark(threadA); 20 System.out.println("执行unpark方法后-------"); 21 } 22 }); 23 24 threadA.start(); 25 threadB.start(); 26 }
这个无论执行多少次，那句 “执行Park方法后—-“，不会执行，因为被阻塞了
根据这个类的特性表明也可以用来控制线程的执行顺序
这个类的其他方法介绍如下
三、AQS的源码简单分析
一、执行流程简述
AQS它的整体流程分为获取锁和释放锁这两个主要流程
1、获取锁的过程：当执行acquire(int)方法时，会以独占模式去获取资源，当获取锁资源成功时，则进入临界区，等待线程调度执行，若失败，则会进入一个队列 中，等待被唤醒出队操作
2、释放锁的过程：在执行release(int)方法时，会去释放锁的资源，如果没有其他线程在等待锁资源(即获取锁资源)，则释放完成，若有，则去唤醒队列中的头结点
二、 内部类Node类简述
1 //表明线程被取消了 2 static final int CANCELLED = 1; 3 /** waitStatus value to indicate successor's thread needs unparking 意思是，这个值代表着这个node节点的后继节点需要被唤醒*/ 4 static final int SIGNAL = -1; 5 /** waitStatus value to indicate thread is waiting on condition 意思是，该值代表线程在等待一个条件*/ 6 static final int CONDITION = -2; 7 /** 8 * waitStatus value to indicate the next acquireShared should 大致意思是，该值表明下一个需要被分享的节点应该无条件被分享 9 * unconditionally propagate 10 */ 11 static final int PROPAGATE = -3;
三、源码分析
3.1获取锁过程分析
在了解acquire(int)方法前，先来了解其内部要用到的两个方法tryAcquire(int)和acquireQueued(Node,int)
1、tryAcquire(int)源码如下，它的作用就是尝试去获取锁资源，获取成功，则返回true，获取失败返回true
1 protected boolean tryAcquire(int arg) { 2 throw new UnsupportedOperationException(); 3 }
咦，怎么会抛异常，是的你没看错，这是AQS内部的tryAcquire(int)方法，因为该类是个抽象类，当继承该类时，要去重写tryAcquire(int)方法，至于它为啥不去弄一个个抽象方法，这个还真不知道！！！它需要AQS子类去自行实现获取锁资源的代码，关于它的某个实现，你也可以去看看前面一片博文的介绍
<ThreadPoolExecutor的分析(二)>中的worker类。
2、acquireQueued(Node,int)源码如下
1 final boolean acquireQueued(final Node node, int arg) { 2 boolean failed = true; //失败标志 3 try { 4 boolean interrupted = false;//线程中断标志 5 for (;;) { 6 final Node p = node.predecessor();//获取node的前一个节点 7 if (p == head && tryAcquire(arg)) {//若满足p是头结点，则尝试获取锁资源， 8 setHead(node);//将node设为头结点 9 p.next = null; // help GC 10 failed = false;//将失败标志标位false 11 return interrupted; 12 }//获取锁失败后，进行挂起操作 13 if (shouldParkAfterFailedAcquire(p, node) && 14 parkAndCheckInterrupt()) 15 interrupted = true; 16 } 17 } finally { 18 if (failed)//进行失败的处理逻辑 19 cancelAcquire(node); 20 } 21 }
先来了解下acquire(int)方法，其源码如下
1 public final void acquire(int arg) { 2 if (!tryAcquire(arg) && 3 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 4 selfInterrupt(); 5 }
当执行该方法时，会先去调用tryAcquire(int)方法来尝试获取所资源，若成功，则进入临界区，若失败，则执行acquireQueued方法，当其返回true，则执行selfInterrupt方法，即中断当前线程。
addWaiter（node）分析
1 private Node addWaiter(Node mode) { 2 Node node = new Node(Thread.currentThread(), mode); 3 // Try the fast path of enq; backup to full enq on failure 4 Node pred = tail;
4 //作用是将node节点置为tail节点 5 if (pred != null) { 6 node.prev = pred; 7 if (compareAndSetTail(pred, node)) {//执行成功表明node节点成功置为tail节点，若失败，可能是由其他的线程也在进行此操作，失败也不会在此一直等，会留到enq中等待 8 pred.next = node; 9 return node; 10 } 11 } 12 enq(node);//执行入队操作 13 return node; 14 }
enq(node)分析
1 private Node enq(final Node node) { 2 //通过for循环来讲node节点置为tail节点，有那种不成功不回头的决心 3 for (;;) { 4 Node t = tail; 5 if (t == null) { // Must initialize 6 //初始化头结点 7 if (compareAndSetHead(new Node())) 8 tail = head; 9 } else { 10 node.prev = t; 11 //执行成功表明node节点成功置为tail节点，若失败，可能是由其他的线程也在进行此操作 12 if (compareAndSetTail(t, node)) { 13 t.next = node; 14 return t; 15 } 16 } 17 } 18 }
shouldParkAfterFailAcquire（node,node）
1 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { 2 int ws = pred.waitStatus; 3 if (ws == Node.SIGNAL) 4 /* 5 * This node has already set status asking a release 当pred处于signal状态表这个节点请求释放 6 * to signal it, so it can safely park.可以将这个节点挂起 7 */ 8 return true; 9 if (ws > 0) { 10 /* 表明pred节点被取消了，然后通过do-while循环去找状态小于0的节点 11 * Predecessor was cancelled. Skip over predecessors and 12 * indicate retry. 13 */ 14 do { 15 node.prev = pred = pred.prev; 16 } while (pred.waitStatus > 0); 17 pred.next = node; 18 } else { 19 /* 到了这里，表名这个状态值一定为0或propagate，之后把状态值设为signal 20 * 21 * 22 * 23 */ 24 compareAndSetWaitStatus(pred, ws, Node.SIGNAL);// 25 } 26 return false; 27 }
3.2，释放锁过程分析
一、前面也说到在执行释放的时候，会先去通过tryRelease(int)获取锁资源，若成功，则之后通过unparkSuccessor来进行具体的释放操作
其中tryRelease也是一个需要子类去实现的方法。
unparkSuccessor的源码如下
1 private void unparkSuccessor(Node node) { 2 /* 如果node类中的的状态值是负数的话，（可能需要signal这个状态）， 3 * 尝试清除。若等待的线程的状态值被改变的话，就会失败，否则成功 4 * If status is negative (i.e., possibly needing signal) try 5 * to clear in anticipation of signalling. It is OK if this 6 * fails or if status is changed by waiting thread. 7 */ 8 int ws = node.waitStatus;//获取node节点的状态值 9 if (ws < 0)//小于0，则表明该node节点状态不是CANCELLED 10 //尝试交换ws和0的值，成功则true，否则代表着有其他线程已经改变了该node的状态值 11 compareAndSetWaitStatus(node, ws, 0); 12 13 /* unpark方法会在该节点后续节点中执行，通常情况下，下一个节点中，如果 14 * 节点状态值时CANCELLED或者为null，那么就从tail节点向前找状态值不是 15 * CANCELLED的node节点 16 * Thread to unpark is held in successor, which is normally 17 * just the next node. But if cancelled or apparently null, 18 * traverse backwards from tail to find the actual 19 * non-cancelled successor. 20 */ 21 Node s = node.next; 22 if (s == null || s.waitStatus > 0) { 23 s = null; 24 通过for循环来寻找靠近node(也可理解为head)节点的节点(后者是状态值不是CANCELLED的节点) 25 for (Node t = tail; t != null && t != node; t = t.prev) 26 if (t.waitStatus <= 0) 27 s = t; 28 } 29 if (s != null)//找到了就给该node节点的线程一个通行证 30 LockSupport.unpark(s.thread); 31 }
总结：以上就是AQS的源码解析，及涉及到的代码及相应的逻辑，当然上面的一些结论是很浅的一些。
(对于以上结论，是本人自己研究和结合网上的一些知识写出来的，仅供参考，若有不足之处，还请指出)
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/12347.html