聊聊高并发（十三）实现几种自旋锁（六）

聊聊高并发（十一）实现几种自旋锁（五） 给出了限时有界队列锁的lock和unlock实现，这篇给出tryLock的实现

tryLock比lock稍微复杂一点，要处理超时的情况。超时有几种情况：

1. 第一步在等待队列还没有获得节点的时候超时，直接返回false即可

2. 第二步在等待队列已经获得节点但是还没有加入工作队列时超时，把节点状态可以直接改成FREE给后续线程使用，然后返回false即可

3. 第三步在前一个节点的状态上自旋时超时，将节点的preNode设置成前一个节点，然后将节点状态改成ABORTED，然后返回即可。后续节点在该节点的状态自旋，当发现这个前驱节点已经是ABORTED了，后续节点就把前驱节点的preNode上自旋，然后把这个节点状态改成FREE,给其他线程使用。

QNode的preNode字段只有当在工作队列中超时的时候才会被设置，也只被后续节点使用一次，而且该域总是先设置，再使用，所以也不需要显式地在其他地方清空该域。

public boolean trylock(long time, TimeUnit unit)
			throws InterruptedException {
		long startTime = System.currentTimeMillis();
		long duration = TimeUnit.MILLISECONDS.convert(time, unit);
		long expectedTime = startTime + duration;

		Backoff backoff = new Backoff(MIN_BACKOFF, MAX_BACKOFF);
		QNode node = waitings[random.nextInt(SIZE)];

		// 第一步: 先获得数组里的一个Node，并把它的状态设置为WAITING，否则就自旋
		GETNODE: while (true) {
			while (node.state.get() != State.FREE) {
				// 因为释放锁时只是设置了State为RELEASED,由后继的线程来设置RELEASED为FREE
				// 如果该节点已经是队尾节点了并且是RELEASED，那么可以直接可以被使用
				// 获取当前原子引用变量的版本号
				int[] currentStamp = new int[1];
				QNode tailNode = tail.get(currentStamp);
				if (tailNode == node && (tailNode.state.get() == State.ABORTED || tailNode.state.get() == State.RELEASED)) {
					QNode preNode = null;
					// 如果最后一个节点是ABORTED状态，就把tail指向它的前一个节点
					if(tailNode.state.get() == State.ABORTED){
						preNode = tailNode.preNode;
					}
				
					if (tail.compareAndSet(tailNode, preNode, currentStamp[0],
							currentStamp[0] + 1)) {
						node.state.set(State.WAITING);
						break GETNODE;
					}
				}
			}
			if (node.state.compareAndSet(State.FREE, State.WAITING)) {
				break;
			}
			try {
				backoff.backoff();
			} catch (InterruptedException e) {
				return false;
			}
			if (timeout(expectedTime, System.currentTimeMillis())) {
				return false;
			}
		}
		// 第二步加入队列
		int[] currentStamp = new int[1];
		QNode preTailNode = null;
		do {
			preTailNode = tail.get(currentStamp);
			// 如果未加入队列前超时，就设置node状态为FREE，给后续线程使用
			if (timeout(expectedTime, System.currentTimeMillis())) {
				node.state.set(State.FREE);
				return false;
			}
		}
		// 如果没加入队列，就一直自旋
		while (!tail.compareAndSet(preTailNode, node, currentStamp[0],
				currentStamp[0] + 1));

		// 第三步在前一个节点自旋，如果前一个节点为null，证明是第一个加入队列的节点
		if (preTailNode != null) {
			// 在前一个节点的状态自旋
			State s = preTailNode.state.get();
			while (s != State.RELEASED) {
				if(s == State.ABORTED){
					QNode temp = preTailNode;
					preTailNode = preTailNode.preNode;
					// 可以释放该节点
					temp.state.set(State.FREE);
				}
				if (timeout(expectedTime, System.currentTimeMillis())) {
					node.preNode = preTailNode;
					node.state.set(State.ABORTED);
					return false;
				}
				s = preTailNode.state.get();
			}
			// 设置前一个节点的状态为FREE,可以被其他线程使用
			preTailNode.state.set(State.FREE);
		}

		// 将线程的myNode指向获得锁的node
		myNode.set(node);
		return true;
	}