java多线程高级-AQS（三）
java多线程高级-AQS（三）
前面第一章介绍了锁的结构，现在介绍java里面的java.util.Concurrent包的里面的基石，AQS。
什么是AQS?
AbstractQueuedSynchronizer（后面简称AQS）AQS是JDK1.5提供的一个基于FIFO等待队列实现的一个用于实现同步器的基础框架，这个基础框架的重要性可以这么说，JUC（java.util.Concurrent）包里面几乎所有的有关锁、多线程并发以及线程同步器等重要组件的实现都是基于AQS这个框架。AQS的核心思想是基于volatile int state这样的一个属性同时配合Unsafe工具对其原子性的操作来实现对当前锁的状态进行修改。当state的值为0的时候，标识改Lock不被任何线程所占有。
AQS源码分析
AQS大致实现流程图
图说明：
private Lock lock = new ReentrantLockSource();
public void serviceA() {
lock.lock();
....
lock.unlock();
}当执行lock.lock()时，就发生了我们图中的关系图了。
假如现在有两个线程（线程1，线程2）同时执行到了lock()方法了，线程1，2开始到了NonfairSync，做了一次尝试获取锁（CAS）明显有且只有一个线程能获取到锁，开始设置lock对象的全局变量，保证不让其它线程往下执行。
假如线程获取到了，1开始执行lock()方法后面的代码；线程2开始进入下一步中。
线程1：cas获取成功，往下执行代码；
线程2:cas失败，开始进入创建队列慢慢路；线程2开始下面几步创建等待队列
- 在创建node节点的时候看看线程1释放了锁没有，释放了，那接着往下执行，就不创建队列；
- 线程1还是没有释放锁，开始创建node节点，查看是否有队列了，没有创建队列，然后跟在队列头后面；如果有队列了，就跟在队列最后面；然后返回node节点。
- 开始检查队列中是否有node可以获取锁了，可以则当前线程可以跳出无线循环，往下执行代码了。当前队列没有一个获取锁的，则无限循环继续查找是否有node可以获取线程。（每个线程都在无限循环，当head节点指向自己线程的node时就可以跳出循环了）
开始竞争执行权
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
//线程1先进入尝试设置状态，如果成功则获取到执行权
//线程1获取锁，设置状态=1；
if (compareAndSetState(0, 1)) {
//标示当前已经获取了锁。
setExclusiveOwnerThread(Thread.currentThread());
} else
//线程2没有获取锁，需要做一些列事：创建队列或者追加队列后面；阻塞自己，不在往下继续执行。
acquire(1);//第二个线程开始尝试获取锁
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}compareAndSetState是一个本地方法CAS操作，线程1，线程2只会有一个成功，成功的继续执行lock后面的代码，失败的进入等待队列。
acquire创建node
创建队列之前，再次尝试是否能获取执行权力，看看线程1是否已经执行完毕了。
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}tryAcquire-> nonfairTryAcquire
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
System.out.println("nonfairTryAcquire没有锁了哦:" + current.getId());
int c = getState();//getstate是volatile，
System.out.println("再次获取锁状态，看看有没有机会获取锁c:" + c);
if (c == 0) {
//state对线程2具有可见性，线程2拿到最新的state，再次判断一下能否持有锁（可能线程1同步代码执行得比较快，这会儿已经释放了锁），不可以就返回false。
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//判断当前是否是自己，如果是第一个线程再次调用了lock方法，nextc状态+1，这就是可重入了
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow//Integer.MAX_VALUE次，也就是2147483647,超过integer最大值会变负数
//这也说明了线程锁可重入的最大次数
throw new Error("Maximum lock count exceeded");
setState(nextc);//状态+1，并不会再次加锁，这就是可重入了。
return true;
}
return false;
}进入等待队列之前再次cas一次，看看线程1是否已经执行完毕了，那线程2就可以直接执行了，而不用进入等待队列。
开始创建等待队列
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
System.out.println("addWaiter:创建等待队列：waitStatus" + node.waitStatus);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;//node节点指向最后一个节点
if (pred != null) {
System.out.println("tail不等于空哦：" + pred.thread.getId());
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
System.out.println("new node追加到队列尾巴");
return node;
}
}
System.out.println("队列为null，创建新的队列");
//创建一个新的队列
enq(node);
return node;
}创建等待之前先判断是否已经有队列了，有则最佳到队尾。没有则开始enq
真正创建队列了
enq
private Node enq(final Node node) {
//这里使用了无限循环，配合下面的compareAndSet**方法的使用。
//compareAndSet**方法里面是一个CAS，如果设置失败了，就返回false，
//如果CAS返回false了，就在循环一直循环直到创建成功为止。
for (; ; ) {
System.out.println("无限循环中.......");
Node t = tail;
if (t == null) { // Must initialize
//如果没有节点，开始使用cas方式创建一个head节点
if (compareAndSetHead(new Node()))
tail = head;
} else {
//node的上一个节点指向了t
node.prev = t;
//如果节点存在，则追加到队列的下一个节点。
System.out.println("队列终于不为null了");
if (compareAndSetTail(t, node)) {
//t的下一个队列指向了node；这是一个双向队列
t.next = node;
System.out.println("开始创建把节点追加到队列尾巴去，并返回节点");
return t;
}
}
}
}等待队列acquireQueued
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
System.out.println("acquireQueued:新创建的等待节点，开始加入到队列里面了");
try {
boolean interrupted = false;
//无限循环，线程2被锁了，一直在等待线程1释放锁
for (; ; ) {
final Node p = node.predecessor();
//线程2尝试能否再次获取锁
if (p == head && tryAcquire(arg)) {
//线程2获取到了锁，线程2的node将成为队列头
System.out.println("获取锁后开始称为称为对头threadid:" + node.thread.getId());
setHead(node);
//丢去之前的队列头，这就是一个线程一个节点（第一个获取锁的线程不在队列里面），线程执行完毕后就把节点删除
p.next = null; // help GC
failed = false;
return interrupted;
}
//shouldParkAfterFailedAcquire设置线程等待，
//parkAndCheckInterrupt阻塞线程2停止往下执行；（这里是有2个线程，假设线程1先获取了锁，线程2执行lock时的内部操作）
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt()) {
interrupted = true;
System.out.println("加锁了，线程被挂起了。");
}
}
} finally {
if (failed)
cancelAcquire(node);
}
}unlock取消锁
public final boolean release(int arg) {
//尝试解锁
//tryRelease只是把各种状态还原到初始化之前而已。
if (tryRelease(arg)) {
System.out.println("解锁成功，开始指向下一个节点，就是下一个线程获取锁的时候了");
Node h = head;//指向了线程2的node
//真正的解锁是在这里，线程1先获取了执行权，线程1可以执行；线程2才是被那个lock住的，所以这里开始唤醒线程2了。
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}tryRelease开始尝试解锁
protected final boolean tryRelease(int releases) {
//getState()-1，和前面的setState对应，就是说线程1加了多少锁，就需要解多少锁。
int c = getState() - releases;
System.out.println("tryRelease开始解锁了c=" + c);
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}setStatus+1,加了几次也需要-1几次，直到为0时才为真正解锁。
tryRelease尝试成功后开始解锁 -> unparkSuccessor
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.
*/
//等待时被设置为-1了，
int ws = node.waitStatus;
System.out.println("unparkSuccessor-ws:" + ws);
//现在获得锁了，把自己的状态置为0
if (ws < 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;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
//线程2不为空，解锁
if (s != null)
LockSupport.unpark(s.thread);
}tryLock尝试获取锁
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//检查是否能获取锁，能获取锁就把自己设置为锁拥有者，就可以往下执行了。
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//检查是否是锁重入，就是自己已经拥有锁了，想再次获取锁。
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
//没有能获取到锁，直接返回false，不做任何操作。
return false;
}tryLock的源码已经很清楚了，只是尝试看看自己能否获取锁，能获取就获取并返回true，不能获取就直接返回false，没有获取锁的时候并不会把线程加入到等待队列里面。所有tryLock只是在能获取锁的时候获取锁。
加锁解锁总结
1.加锁解锁过程是这样的
- 线程1执行lock时，获得了执行权，就开始执行了。
- 线程2执行lock时，发现获取不到执行权，就开始进入等待队列，并且把自己的当前线程2挂起。
- 线程1执行完后，调用unlock，unlock把线程2从加锁队列中解锁出来。
所以说加锁时把自己给锁住，解锁是有执行权限的线程去解救被锁住的线程。
2.从上面的代码也可以看出，AQS中每操作一步遇到线程竞争的过程都是采用CAS的无锁操作的（没有使用synchronized）
参看文献
http://www.cnblogs.com/xrq730/p/4979021.html