LockSupport簡介:

LockSupport是一個非常方便實用的執行緒阻塞工具,它可以線上程任意位置讓執行緒阻塞.和Thread.suspend()相比,它彌補了由於resume()在前發生,導致執行緒無法繼續執行的情況.和Object.wait()相比,它不需要先獲得物件的鎖,也不會丟擲中斷異常.

LockSupport是用於建立鎖和其他同步類的基本執行緒阻塞原語.

LockSupport是通過Unsafe類來實現的.

Unsafe的主要方法:

	/***
	 * 釋放由park方法建立的鎖
	 * 此方法也用於終止之前的park引起的阻塞
	 * 這個操作是不安全的，因為執行緒必須保證是活的 
	 * @param thread
	 *            解鎖的執行緒
	 */
	public native void unpark(Thread thread);

	/**
	 * 阻止執行緒，直到匹配的unpark發生，執行緒中斷或可選超時到期
	 * @param isAbsolute	是否是相對時間
	 * @param time		為0表示不設定超時
	 */
	public native void park(boolean isAbsolute, long time);
 

先來解析下兩個函式是做什麼的。
unpark函式為執行緒提供“許可(permit)”，執行緒呼叫park函式則等待“許可”。這個有點像訊號量，但是這個“許可”是不能疊加的，“許可”是一次性的。
比如執行緒B連續呼叫了三次unpark函式，當執行緒A呼叫park函式就使用掉這個“許可”，如果執行緒A再次呼叫park，則進入等待狀態。
注意，unpark函式可以先於park呼叫。比如執行緒B呼叫unpark函式，給執行緒A發了一個“許可”，那麼當執行緒A呼叫park時，它發現已經有“許可”了，那麼它會馬上再繼續執行。
實際上，park函式即使沒有“許可”，有時也會無理由地返回.

park和unpark的靈活之處
上面已經提到，unpark函式可以先於park呼叫，這個正是它們的靈活之處。
一個執行緒它有可能在別的執行緒unPark之前，或者之後，或者同時呼叫了park，那麼因為park的特性，它可以不用擔心自己的park的時序問題，否則，如果park必須要在unpark之前，那麼給程式設計帶來很大的麻煩！！
考慮一下，兩個執行緒同步，要如何處理？
在Java5裡是用wait/notify/notifyAll來同步的。wait/notify機制有個很蛋疼的地方是，比如執行緒B要用notify通知執行緒A，那麼執行緒B要確保執行緒A已經在wait呼叫上等待了，否則執行緒A可能永遠都在等待。程式設計的時候就會很蛋疼。
另外，是呼叫notify，還是notifyAll？
notify只會喚醒一個執行緒，如果錯誤地有兩個執行緒在同一個物件上wait等待，那麼又悲劇了。為了安全起見，貌似只能呼叫notifyAll了。
park/unpark模型真正解耦了執行緒之間的同步，執行緒之間不再需要一個Object或者其它變數來儲存狀態，不再需要關心對方的狀態.(摘自

點選開啟連結)

下面來看看LockSupport的原始碼:

	private LockSupport() {
	} // 無法例項化。

	private static void setBlocker(Thread t, Object arg) {
		// 即使是volatile, hotspot虛擬節機也不需要在此設定屏障
		UNSAFE.putObject(t, parkBlockerOffset, arg);
	}

	/**
	 * 如果給定的執行緒許可不可用的時候呼叫此方法將變成可用. 如果執行緒在park上被阻塞，那麼它將被解除阻塞
	 * 否則，它的下一次呼叫park保證不被阻塞
	 * 如果給定的執行緒尚未啟動，則此操作根本無法保證任何效果
	 * 
	 * @param 將執行緒執行緒解除標記，或{@code null}，在這種情況下，此操作不起作用
	 */
	public static void unpark(Thread thread) {
		if (thread != null)
			UNSAFE.unpark(thread);
	}

	/**
	 * 禁用當前執行緒進行執行緒排程，除非許可證可用 如果許可可用，則它被消耗，並且該呼叫立即返回
	 * 否則當前執行緒將被禁用以進行執行緒排程，並且處於休眠狀態，直至發生三件事情之一
	 *
	 * 1.一些其他執行緒呼叫當前執行緒作為目標unpark
	 * 2.一些其他執行緒中斷當前執行緒
	 * 3.不合邏輯呼叫的返回
	 * 此方法不報告其中哪一個導致返回的方法 
	 * 呼叫者應重新檢查導致執行緒首先park的條件。 呼叫者也可以確定， 例如，執行緒在返回時的中斷狀態
	 * 
	 * @param 阻止同步物件負責此執行緒park
	 */
	public static void park(Object blocker) {
		Thread t = Thread.currentThread();
		setBlocker(t, blocker);
		UNSAFE.park(false, 0L);
		setBlocker(t, null);
	}

	/**
	 * 同上 增加等待時間
	 */
	public static void parkNanos(Object blocker, long nanos) {
		if (nanos > 0) {
			Thread t = Thread.currentThread();
			setBlocker(t, blocker);
			UNSAFE.park(false, nanos);
			setBlocker(t, null);
		}
	}

	/**
	 * 禁用當前執行緒進行執行緒排程，直到指定的截止日期，除非許可可用
	 */
	public static void parkUntil(Object blocker, long deadline) {
		Thread t = Thread.currentThread();
		setBlocker(t, blocker);
		UNSAFE.park(true, deadline);
		setBlocker(t, null);
	}

	/**
	 * 返回提供給最新一次呼叫尚未解除阻塞的park方法blocker物件，如果不阻塞則返回null 
	 */
	public static Object getBlocker(Thread t) {
		if (t == null)
			throw new NullPointerException();
		return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
	}

	/**
	 * 禁用當前執行緒進行執行緒排程，除非許可證可用
	 */
	public static void park() {
		UNSAFE.park(false, 0L);
	}
 

demo:

public class LockSupportDemo {
	public static Object u = new Object();
	static ChangeObjectThread t1 = new ChangeObjectThread("t1");
	static ChangeObjectThread t2 = new ChangeObjectThread("t2");

	public static class ChangeObjectThread extends Thread {
		public ChangeObjectThread(String name){
			super.setName(name);
		}
		@Override
		public void run() {
			synchronized (u) {
				System.out.println("in "+getName());
				LockSupport.park(this);
			}
		}
	}
	public static void main(String[] args) throws InterruptedException {
		t1.start();
		Thread.sleep(1000);
		t2.start();
		LockSupport.unpark(t1);
		LockSupport.unpark(t2);
		t1.join();
		t2.join();
	}
}