LockSupport源码分析(JDK 1.7)

LockSupport是用来创建锁和其他同步类的基本线程阻塞基本体(primitives)。通过调用LockSupport的park方法可以申请一个许可，如果当前许可可用的话，那么则立即返回，否则则阻塞等待许可。直到另外一个线程调用unpark方法对被阻塞的线程的许可进行释放。(默认许可阻塞)

park方法还支持Blocker对象参数，在调用park方法对当前线程进行阻塞时候，可以把Blocker对象参数传递过来，LockSupport的park方法里会调用setBlocker方法把该对象参数存入到Thread里的parkBlocker变量里。我们可以通过getBlocker获取线程的parkBlocker变量，从而得知该线程正在被阻塞的原因。

public class LockSupport {
private LockSupport() {} // 禁止创建对象

// Unsafe实际上调用的都是本地方法native
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long parkBlockerOffset;

static {
try {
//获取Thread的成员变量parkBlocker的偏移量
parkBlockerOffset = unsafe.objectFieldOffset
(java.lang.Thread.class.getDeclaredField("parkBlocker"));
} catch (Exception ex) { throw new Error(ex); }
}
//设置Blocker对象到Thread对象里面
private static void setBlocker(Thread t, Object arg) {
// Even though volatile, hotspot doesn't need a write barrier here.
unsafe.putObject(t, parkBlockerOffset, arg);
}

//获取先前park时候存入的线程的Blocker，如果未存入或者当前线程并不在park里，则为null
public static Object getBlocker(Thread t) {
if (t == null)
throw new NullPointerException();
return unsafe.getObjectVolatile(t, parkBlockerOffset);
}

//对于给定的Thread释放它所占有的许可。如果当前线程已经占有许可，则释放。如果为占有也释放，那么下次调用该线程的unpark方法时候
//会导致park直接获取了。因为上次已经释放了
public static void unpark(Thread thread) {
if (thread != null)
unsafe.unpark(thread);
}

//挂起当前线程,且把Blocker存到线程中
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
//false代表非绝对时间（即相对时间）
unsafe.park(false, 0L);
setBlocker(t, null);
}
}

以上是LockSupport源码的分析，除了上面说提到的Park(Object obj)，还有两个Park重载方法，分别提供了可设定线程挂起的绝对时间和相对时间方法。

下面是个LockSupport的使用例子

利用LockSupport实现了一个先进先出（FIFO）阻塞线程队列功能，即每一条线程入队后都只能排队依次等待执行

class FIFOMutex {
private final AtomicBoolean locked = new AtomicBoolean(false);
private final Queue waiters = new ConcurrentLinkedQueue();

public void lock() {
boolean wasInterrupted = false;
//首先获取当前线程，然后存入waiters 队列头部
Thread current = Thread.currentThread();
waiters.add(current);

// 先循环判断是否满足线程挂起条件
while (waiters.peek() != current ||
!locked.compareAndSet(false, true)) {
//把当前的FIFOMutex 对象传递到 LockSupport.park(this)，LockSupport会把this给赋值到当前Thread的变量里
LockSupport.park(this);
if (Thread.interrupted()) // ignore interrupts while waiting
wasInterrupted = true;
}
//上面那段while循环主要是负责阻塞挂起线程。当挂起条件不满足后则跳出循环
//删除队列头部已被阻塞完成的线程
waiters.remove();
if (wasInterrupted)          // reassert interrupt status on exit
current.interrupt();
}
//释放线程
public void unlock() {
locked.set(false);
LockSupport.unpark(waiters.peek());
}
}}

//TestFIFOMutex是FIFOMutex的测试例子
import java.util.Date;

public class TestFIFOMutex {

private static FIFOMutex mutex = new FIFOMutex();

public static void main(String[] args) {
new Thread(new Runnable(){
@Override
public void run() {
sleep(1000 * 2);
System.out.println(new Date().toGMTString()+" :t1 准备lock");
mutex.lock();
System.out.println(new Date().toGMTString()+" :t1 完成lock");
}
}).start();

new Thread(new Runnable(){
@Override
public void run() {
sleep(1000 * 3);
System.out.println(new Date().toGMTString()+" :t2 准备lock");
mutex.lock();
System.out.println(new Date().toGMTString()+" :t2 完成lock");
}
}).start();

new Thread(new Runnable(){
@Override
public void run() {
sleep(1000 * 5);
System.out.println(new Date().toGMTString()+" :t3 准备 unlock释放");
mutex.unlock();
System.out.println(new Date().toGMTString()+" :t3 释放完毕unlock");
}
}).start();
}

public static void sleep(long num){
try {
Thread.sleep(num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

//TestFIFOMutex执行结果
24 Nov 2015 14:33:46 GMT :t1 准备lock
24 Nov 2015 14:33:46 GMT :t1 完成lock
24 Nov 2015 14:33:47 GMT :t2 准备lock
24 Nov 2015 14:33:49 GMT :t3 准备 unlock释放
24 Nov 2015 14:33:49 GMT :t2 完成lock
24 Nov 2015 14:33:49 GMT :t3 释放完毕unlock

通过上面这个测试，可以观察到t2 完成lock必须得等到t3进行unlock。因为t2线程已经给park挂起了，必须得等待unpark唤醒