说明：本作者是文章的原创作者，转载请注明出处：本文地址：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方法时却不会阻塞，下面看这个类的示例代码
public class TestLockSupport {
public static void main(String[] args) {
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("执行park方法前-------");//----1----
//执行下面方法后threadA线程会阻塞
LockSupport.park();
System.out.println("执行park方法后-------");
}
});
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("执行unpark方法前-------");//----2----
//给threadA颁发一个许可证
LockSupport.unpark(threadA);
try {
Thread.sleep(1000);//这个作用是为了更好的演示
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("执行unpark方法后-------");
}
});
threadA.start();
threadB.start();
}
}
执行结果如下(结果并不唯一）
执行park方法前-------
执行unpark方法前-------
执行park方法后-------
执行unpark方法后-------
值得注意的是，一个线程只能拥有一个许可证，简单的说就是当线程A内执行n(n>1)个park方法，你在线程B内也执行n个unpark(线程A)，按照正常理解，线程A内不会阻塞，但不巧的是，它阻塞了，示例代码如下
public static void main(String[] args) {
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("执行park方法前-------");//----1----
LockSupport.park();
LockSupport.park();
System.out.println("执行park方法后-------");
}
});
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("执行unpark方法前-------");//----2----
LockSupport.unpark(threadA);
LockSupport.unpark(threadA);
System.out.println("执行unpark方法后-------");
}
});
threadA.start();
threadB.start();
}
这个无论执行多少次，那句 "执行Park方法后----"，不会执行，因为被阻塞了
根据这个类的特性表明也可以用来控制线程的执行顺序
这个类的其他方法介绍如下
三、AQS的源码简单分析
一、执行流程简述
AQS它的整体流程分为获取锁和释放锁这两个主要流程
1、获取锁的过程：当执行acquire(int)方法时，会以独占模式去获取资源，当获取锁资源成功时，则进入临界区，等待线程调度执行，若失败，则会进入一个队列 中，等待被唤醒出队操作
2、释放锁的过程：在执行release(int)方法时，会去释放锁的资源，如果没有其他线程在等待锁资源(即获取锁资源)，则释放完成，若有，则去唤醒队列中的头结点
二、 内部类Node类简述
//表明线程被取消了
static final int CANCELLED = 1;
/** waitStatus value to indicate successor's thread needs unparking 意思是，这个值代表着这个node节点的后继节点需要被唤醒*/
static final int SIGNAL = -1;
/** waitStatus value to indicate thread is waiting on condition 意思是，该值代表线程在等待一个条件*/
static final int CONDITION = -2;
/**
* waitStatus value to indicate the next acquireShared should 大致意思是，该值表明下一个需要被分享的节点应该无条件被分享
* unconditionally propagate
*/
static final int PROPAGATE = -3;
三、源码分析
3.1获取锁过程分析
在了解acquire(int)方法前，先来了解其内部要用到的两个方法tryAcquire(int)和acquireQueued(Node,int)
1、tryAcquire(int)源码如下，它的作用就是尝试去获取锁资源，获取成功，则返回true，获取失败返回true
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
咦，怎么会抛异常，是的你没看错，这是AQS内部的tryAcquire(int)方法，因为该类是个抽象类，当继承该类时，要去重写tryAcquire(int)方法，至于它为啥不去弄一个个抽象方法，这个还真不知道！！！它需要AQS子类去自行实现获取锁资源的代码，关于它的某个实现，你也可以去看看前面一片博文的介绍
<ThreadPoolExecutor的分析(二)>中的worker类。
2、acquireQueued(Node,int)源码如下
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true; //失败标志
try {
boolean interrupted = false;//线程中断标志
for (;;) {
final Node p = node.predecessor();//获取node的前一个节点
if (p == head && tryAcquire(arg)) {//若满足p是头结点，则尝试获取锁资源，
setHead(node);//将node设为头结点
p.next = null; // help GC
failed = false;//将失败标志标位false
return interrupted;
}//获取锁失败后，进行挂起操作
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)//进行失败的处理逻辑
cancelAcquire(node);
}
}
先来了解下acquire(int)方法，其源码如下
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
当执行该方法时，会先去调用tryAcquire(int)方法来尝试获取所资源，若成功，则进入临界区，若失败，则执行acquireQueued方法，当其返回true，则执行selfInterrupt方法，即中断当前线程。
addWaiter（node）分析
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;
4 //作用是将node节点置为tail节点
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {//执行成功表明node节点成功置为tail节点，若失败，可能是由其他的线程也在进行此操作，失败也不会在此一直等，会留到enq中等待
pred.next = node;
return node;
}
}
enq(node);//执行入队操作
return node;
}
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）
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release 当pred处于signal状态表这个节点请求释放
* to signal it, so it can safely park.可以将这个节点挂起
*/
return true;
if (ws > 0) {
/* 表明pred节点被取消了，然后通过do-while循环去找状态小于0的节点
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/* 到了这里，表名这个状态值一定为0或propagate，之后把状态值设为signal
*
*
*
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);//
}
return false;
}
3.2，释放锁过程分析
一、前面也说到在执行释放的时候，会先去通过tryRelease(int)获取锁资源，若成功，则之后通过unparkSuccessor来进行具体的释放操作
其中tryRelease也是一个需要子类去实现的方法。
unparkSuccessor的源码如下
private void unparkSuccessor(Node node) {
/* 如果node类中的的状态值是负数的话，（可能需要signal这个状态），
* 尝试清除。若等待的线程的状态值被改变的话，就会失败，否则成功
* 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;//获取node节点的状态值
if (ws < )//小于0，则表明该node节点状态不是CANCELLED
//尝试交换ws和0的值，成功则true，否则代表着有其他线程已经改变了该node的状态值
compareAndSetWaitStatus(node, ws, );
/* unpark方法会在该节点后续节点中执行，通常情况下，下一个节点中，如果
* 节点状态值时CANCELLED或者为null，那么就从tail节点向前找状态值不是
* CANCELLED的node节点
* 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 > ) {
s = null;
通过for循环来寻找靠近node(也可理解为head)节点的节点(后者是状态值不是CANCELLED的节点)
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= )
s = t;
}
if (s != null)//找到了就给该node节点的线程一个通行证
LockSupport.unpark(s.thread);
}
总结：以上就是AQS的源码解析，及涉及到的代码及相应的逻辑，当然上面的一些结论是很浅的一些。
(对于以上结论，是本人自己研究和结合网上的一些知识写出来的，仅供参考，若有不足之处，还请指出)