ReentrantLock中NonFairSync对于AQS的使用

NonfairSync

final void lock() {
	//利用cas操作修改同步状态从0变为1
	if (compareAndSetState(0, 1))
		//如果修改成功 说明当前无线程执行 将当前线程设置为占用排它锁的线程
		setExclusiveOwnerThread(Thread.currentThread());
	else
		//设置失败 则需要将当前线程加入等待队列
		acquire(1);
}

-------------------------------------------------------------------------------------

public final void acquire(int arg) {
	//tryAcquire 再一次尝试将当前线程设占用排它锁 见nonfairTryAcquire()
	if (!tryAcquire(arg) &&
		//addWaiter 尝试获取锁失败 则将线程加入等待队列
		acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
		selfInterrupt();
		
}

-------------------------------------------------------------------------------------

//仅当同步状态为0 或者本线程冲入的情形 返回true
final boolean nonfairTryAcquire(int acquires) {
	final Thread current = Thread.currentThread();
	int c = getState();
	if (c == 0) {
		//当前同步状态为0 再次设置线程
		if (compareAndSetState(0, acquires)) {
			setExclusiveOwnerThread(current);
			return true;
		}
	}
	else if (current == getExclusiveOwnerThread()) {
		//判断当前线程是否和占据锁的线程是同一个 如果相同 将同步状态加1
		int nextc = c + acquires;
		//可重入次数限制 为Int的最大值 21亿次左右
		if (nextc < 0) // overflow
			throw new Error("Maximum lock count exceeded");
		setState(nextc);
		return true;
	}
	return false;
}



//将当前线程封装成node 加入AQS内部的一个双向链表
private Node addWaiter(Node mode) {
	Node node = new Node(Thread.currentThread(), mode);
	//初次进入时 tail为空 直接进入enq
	//如果tail不为null 说明当前已有线程处于等待状态 
	//将当前线程node的前指针指向原tail节点 再利用cas尝试将tail指向本节点 
	//其实是一个双向链表的末尾插入过程 完成后直接返回node
	Node pred = tail;
	if (pred != null) {
		node.prev = pred;
		if (compareAndSetTail(pred, node)) {
			pred.next = node;
			return node;
		}
	}
	//当前没有等待线程时执行
	enq(node);
	return node;
}



private Node enq(final Node node) {
	//这里需要注意到 可能会有多个线程同时进入for循环 
	//cas操作的目的在于 同一时刻 只能有一条线程成功插入到链表中 其余线程插入失败只能进入下一次循环
	for (;;) {
		Node t = tail;
		if (t == null) { // Must initialize
			//初始化一个空的head节点 再将tail指向head
			if (compareAndSetHead(new Node()))
				tail = head;
		} else {
			//尝试将node插入到尾部
			node.prev = t;
			if (compareAndSetTail(t, node)) {
				t.next = node;
				return t;
			}
		}
	}
}

-------------------------------------------------------------------------------------

final boolean acquireQueued(final Node node, int arg) {
	boolean failed = true;
	try {
		boolean interrupted = false;
		for (;;) {//此处为一个死循环 只有在if (p == head && tryAcquire(arg))才会跳出
			final Node p = node.predecessor();
			//仅当当前node的前节点为head 并且当前线程成功获取到独占锁后进入（tryAcquire的true条件）
			//可以看出 只有当节点处于队列的第二位时 才有机会征用锁
			if (p == head && tryAcquire(arg)) {
				//将当前node内部的线程指针和prev指针置为null 
				setHead(node);
				//将原来的head节点 next指针置为null
				p.next = null; // help GC 此时没有指针指向原head节点 并且node节点成为了新的head节点 完成了一次FIFO的出队操作 当前线程获取了锁
				failed = false;
				return interrupted;
			}
			//只有当p的状态为signal时 才能将node中线程的置为waiting状态（parkAndCheckInterrupt 调用LockSupport.park方法）
			if (shouldParkAfterFailedAcquire(p, node) &&
				parkAndCheckInterrupt())
				interrupted = true;
		}
	} finally {
		if (failed)
			cancelAcquire(node);
	}
}
	
	
 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
	int ws = pred.waitStatus;
	if (ws == Node.SIGNAL)
		//表示前一个节点的状态为SIGNAL 当其线程被唤醒后 就会通知本节点?
		return true;
	if (ws > 0) {
		//大于0的只有Cancel状态
		//目的在于提出掉队列中状态为cancel的节点 当前节点指向前方最靠近它的一个非cancel节点
		do {
			node.prev = pred = pred.prev;
		} while (pred.waitStatus > 0);
		
		pred.next = node;
	} else {
		//此处只有-2：CONDITION  -3：PROPAGATE 对应条件等待 这里尝试通过cas将其状态置为signal
		compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
	}
	return false;
}
-------------------------------------------------------------------------------------
public void unlock() {
	sync.release(1);
}

public final boolean release(int arg) {
	if (tryRelease(arg)) {
		//首先head节点是个空节点 在初始化enq(node)的过程中创建
		Node h = head;
		//h.waitStatus != 0 这里的0状态在unparkSuccessor中有所体现
		if (h != null && h.waitStatus != 0)
			//对于head节点的处理 及唤醒等待队列中后一个节点线程的处理
			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;
	//可重入处理 加锁一次c+1 解锁一次c-1 减到0之后 说明锁被释放
	if (c == 0) {
		free = true;
		setExclusiveOwnerThread(null);
	}
	setState(c);
	return free;
}

private void unparkSuccessor(Node node) {
	int ws = node.waitStatus;
	if (ws < 0)
		//将该节点状态置为0 某种意义上接近于cancel的效果？
		compareAndSetWaitStatus(node, ws, 0);

	//head为空节点 找到head后的节点 
	Node s = node.next;
	//后置节点为空或者后置节点状态为cancel 
	if (s == null || s.waitStatus > 0) {
		s = null;
		//直接指向末尾节点 向前找到最靠前一个非空并且状态不为cancel的节点
		for (Node t = tail; t != null && t != node; t = t.prev)
			if (t.waitStatus <= 0)
				s = t;
	}
	//唤醒该节点的线程 在唤醒后 该节点进入acquireQueued中 继续尝试获取锁 但未必能获取到 
	//tryAcquire这个方法在多个地方都有调用  可能会有线程尚未加入队列就成功获取锁 是否便是非公平锁的体现 没有根据队列FIFO的顺序获取锁
	if (s != null)
		LockSupport.unpark(s.thread);
}
注意在unparkSuccessor中并没有对队列本身做出操作 当前线程节点依然处在原来的位置上 需要回到acquireQueued的循环中才能完成全部的FIFO操作