这篇看一下时限队列锁的一种实现方式。 java并发包中的Lock定义包含了时限锁的接口：

public interface Lock {

    void lock();

    void lockInterruptibly() throws InterruptedException;    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();

    Condition newCondition();
}

因为这两个特性的需要，队列锁的节点需要支持“退出队列”的机制，也就是说当发生超时或者线程中断的情况下，线程能从队列中出队列，不影响其他节点继续等待。之前实现的几种队列锁都不支持退出机制，一旦发生队列中的线程长时间阻塞，那么后续所有的线程都会被动阻塞。

我们看一种限时队列锁的实现，它有几个要点：

1. 定义一个共享的AVAILABLE节点，当一个节点的preNode指向AVAILABLE时，表示这个节点获得锁

2. QNode节点维护一个preNode引用，这个引用只有当获得锁时，会指向AVAILABLE，或者超时了会指向它的前一个节点，其他等待锁的时候都是Null，因为一旦一个节点超时了，需要让它的后续节点指向它的前驱节点，所以只有超时的时候会给preNode设置值（指向AVAILABLE节点除外）。

3. 使用一个AtomicReference原子变量tail来形成一个虚拟的单向链表结构。tail的getAndSet操作会返回之前的节点的引用，相当于获得了前驱节点。当获得锁后，前驱节点引用就释放了，前驱节点就可以被GC回收

4. 支持中断操作，Thread.isInterrupted()可以获得线程中断的信息，一旦获取中断信息，就抛出中断异常。需要注意的时，线程中断信息发出时，并不是要求线程马上中断，而是告知了线程要中断的信息，程序自己控制中断的地点。

5. 由于线程只有一个ThreadLocal的myNode变量指向自己的节点，所以获取锁时，使用了每次new一个新的Node，并设置给线程的方式，避免unlock时对node的操作影响后续节点的状态，也可以使线程多次获得锁。这里可以考虑像CLHLock那样，维护两个ThreadLocal的引用，释放锁时把myNode的引用指向已经不使用的前驱节点，这样避免无谓的new操作。

package com.zc.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/**
 * 时限队列锁，支持tryLock超时操作
 * QNode维护一个指针preNode指向前一个节点。当preNode == AVAILABLE表示已经释放锁。当preNode == null表示等待锁
 * tail维护一个虚拟链表,通过tail.getAndSet方法获得前一个节点,并在前一个节点自旋,当释放锁时前一个节点的preNode == AVAIABLE，自动通知后一个节点获取锁
 * 当一个节点超时或者被中断，那么它的前驱节点不为空。后续节点看到它的前驱节点不为空，并且不是AVAILABLE时，知道这个节点退出了，就会跳过它
 * 当节点获得锁，进入临界区后，它的前驱节点可以被回收
 * **/
public class TimeoutLock implements TryLock{
	// 声明为静态变量，防止被临时回收
	private static final QNode AVAILABLE = new QNode();
	
	// 原子变量指向队尾
	private AtomicReference<QNode> tail;

	ThreadLocal<QNode> myNode;
	
	public TimeoutLock(){
		tail = new AtomicReference<QNode>(null);
		myNode = new ThreadLocal<QNode>(){
			protected QNode initialValue(){
				return new QNode();
			}
		};
	}
	
	@Override
	public void lock() {
		// 和CLHLock不同，每次新建一个Node，并设置给线程，目的是支持同一个线程可以多次获得锁，而不影响链中其他节点的状态
		// CLHLock不需要每次新建Node是因为它使用了两个指针，一个指向前驱节点。而前驱节点释放后就可以回收了。
		// CLHLock每次释放锁时设置myNode为失效的前驱节点，也是为了支持同一个线程可以多次获取锁而不影响其他节点
		QNode node = new QNode();
		myNode.set(node);
		QNode pre = tail.getAndSet(node);
		if(pre != null){
			// 在前一个节点自旋，当前一个节点是AVAILABLE时，表示它获得锁
			while(pre.preNode != AVAILABLE){
				
			}
		}
	}

	@Override
	public void unlock() {
		QNode node = myNode.get();
		// CAS操作，如果为true，表示是唯一节点，直接释放就行；否则把preNode指向AVAILABLE
		if(!tail.compareAndSet(node, null)){
			node.preNode = AVAILABLE;
		}
	}
	
	@Override
	//TimeUnit只支持毫秒
	public boolean trylock(long time, TimeUnit unit) throws InterruptedException {
		if(Thread.interrupted()){
			throw new InterruptedException();
		}
		boolean isInterrupted = false;
		long startTime = System.currentTimeMillis();
		long duration = TimeUnit.MILLISECONDS.convert(time, unit);
		// 注意：每次tryLock都要new新的Node，为了同一个线程可以多次获得锁。如果每个线程都使用同一个节点，会影响链中其他的节点
		QNode node = new QNode();
		myNode.set(node);
		// 尝试一次获取锁
		QNode pre = tail.getAndSet(node);
		// 第一个节点或者之前的节点都是已经释放了锁的节点, pre==AVAILABLE表示获得了锁
		if(pre == null || pre == AVAILABLE){
			return true;
		}
		// 在给定时间内对preNode自旋
		while((System.currentTimeMillis() - startTime < duration) && !isInterrupted){
			QNode predPreNode = pre.preNode;
			// 表示前一个节点已经释放了锁，设置了preNode域，否则preNode域为空
			if(predPreNode == AVAILABLE){
				return true;
			}
			// 当prePreNode ！= null时，只有两种情况，就是它超时了，或者被中断了。
			// 跳过prePreNode不为空的节点，继续自旋它的下一个节点
			else if(predPreNode != null){
				pre = predPreNode;
			}
			if(Thread.interrupted()){
				isInterrupted = true;
			}
		}
		
		// 超时或者interrupted，都要设置node的前驱节点不为空
		node.preNode = pre;
		
		if(isInterrupted){
			throw new InterruptedException();
		}
		
		return false;
	}
	
	public static class QNode {
		volatile QNode preNode;
	}
	
	public String toString(){
		return "TimeoutLock";
	}

}

使用限时锁时有固定的模板，防止锁被错误使用。

Lock lock = ...;
if (lock.tryLock()) {
     try {
     // manipulate protected state
     } finally {
        lock.unlock();
     }
} else {
    // perform alternative actions
}

转载请注明来源: http://blog.csdn.net/iter_zc

聊聊高并发（九）实现几种自旋锁（四）