Lock介面

Java se5之後，出現了Lock介面，提供了與Synchronized類似同步功能。與synchronized相比，他雖然少了隱式獲取釋放鎖的便捷性，卻擁有了鎖獲取與釋放的可操作性、可中斷的獲取鎖以及超時獲取鎖等多種synchronized不具備的同步特性。 Lock的使用方式非常簡單，首先例項化Lock物件 Lock lock = new ReentrantLock（）; 然後在需要的地方加鎖： lock.lock(): try{ //do something }finally{ lock.unlock();//避免發生異常不能釋放鎖 }

佇列同步器

AbstractQueueSynchronizer佇列同步器（以下簡稱同步器），是用來構建鎖或者其他同步元件的基本框架。同步器是實現鎖的關鍵，鎖和同步器的關係如下：鎖是面向使用者的，隱藏了實現細節。而同步器面向的是鎖的實現者，它簡化了鎖的實現方式，遮蔽了同步狀態管理、執行緒的排隊、等待與喚醒等底層操作。

佇列同步器的介面與示例

同步器的設計是基於模板方法模式的，因此，使用者需要繼承同步器並重寫指定的方法，隨後將同步器組合在自定義的同步元件的實現中，並呼叫同步器提供的模板方法。而這些模板方法將會呼叫使用者重寫的方法。 也就是說同步器的方法主要分為兩類：模板方法和可重寫方法。 如下所示 同時，你要重寫可重寫方法，需要使用下面三個方法來訪問或者修改同步狀態 getState（）：獲取當前同步狀態 setState（int newState):設定當前同步狀態 compareAndSetState（int expect，int update）：使用CAS操作設定當前狀態，該方法能保證狀態設定的原子性。 下面我們來看一個同步器的簡單實現；

import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;

public class Mutex {
	private class Sync extends AbstractQueuedSynchronizer{
		//是否處於佔用狀態
		protected boolean isHeldExclusively(){
			return getState()==1;
		}
		//當狀態為0的時候獲取鎖
		public boolean tryAcquire(int acquire){
			if(compareAndSetState(0, 1)){
				setExclusiveOwnerThread(Thread.currentThread());
				return true;
			}
			return false;
		}
		//釋放鎖，將狀態設定為0
		protected boolean tryRease(int releases){
			if(getState()==0){
				throw new IllegalMonitorStateException();
			}
			setExclusiveOwnerThread(null);
			setState(0);
			return true;
		}
		public Condition newCondition() {
			// TODO Auto-generated method stub
			return new ConditionObject();
		}
	}
	public final Sync s = new Sync();
	public void lock(){s.acquire(1);}
	public boolean tryLock(){return s.tryAcquire(1);}
	public void unlock(){s.release(1);}
	public Condition newCondition(){return s.newCondition();}
	public boolean isLocked(){return s.isHeldExclusively();}
	public boolean hasQueueThreads(){return s.hasQueuedThreads();}
	//other methods as same as in Lock

}
 

佇列同步器的實現分析

佇列同步器的實現主要包括以下幾個方面：同步佇列、度展示同步狀態獲取與釋放、共享式同步狀態獲取與釋放、以及超時獲取同步狀態等同步器的核心資料結構和模板方法。

同步佇列

同步器依賴同步佇列---一個雙向的FIFO佇列----來完成同步狀態的管理。當前執行緒獲取同步狀態失敗時，同步器會將當前執行緒以及等待狀態等資訊封裝的成一個節點放入同步佇列，同時會阻塞當前執行緒。當同步狀態釋放時，會把首節點的執行緒喚醒，使其再次嘗試獲得同步狀態。 同步器擁有首節點和為節點，每當一個執行緒獲取同步狀態失敗，都會加入這個同步佇列的尾部，這個操作是要保證執行緒安全的，也就是說，必須使用CAS操作。同步器提供了一個CAS方法：compareAndSetTail(node expect,node update)
同步器持有的同步佇列的節點喚醒基本過程就是：首先，首節點是獲取同步狀態成功的節點，當同步狀態被當前首節點釋放時，後繼的節點會在獲取同步狀態成功時將自己設定為首節點。同時這個過程是由獲得同步狀態成功的執行緒來執行的，因此不需要CAS操作。

獨佔式同步狀態的獲取和釋放

通過呼叫同步器的acquire方法可以獲得同步狀態。該方法對中斷不敏感，也就是和synchronized一樣，對於獲得鎖之後的中斷不會執行中斷操作。同步器的acquire方法呼叫了我們在自定義同步器類Sync中的tryAcquire（）方法。其原始碼如下所示：

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

這個方法的if語句作了三個操作：獲取同步狀態，如果上一步不成功則進行節點構造並將節點加入同步佇列（addWaiter（）方法），並在同步佇列中自旋（acquireQueued()方法）。我麼前面已經實現了tryAcquire，下面我們來看看addWaiter的原始碼

 private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

上面的程式碼首先建立了一個儲存當前節點和其狀態的Node例項node，然後將當前尾節點儲存（Node pred = tail）。接下來在if語句中，如果當前尾節點非空，表示佇列非空，那麼就讓node的前一個節點指標pre指向pred，同時compareAndSetTail方法確保節點能夠被獨立的設定為尾節點。然後讓pred的下一個節點指向node，也就是現在的尾節點。enq（node）通過死迴圈的方式來保證節點正確新增。
節點進入佇列後，就保持自旋的狀態來觀察，當條件滿足，獲取到了同步狀態，那麼就可以從自旋中退出。如下面的程式碼所示：

 final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

共享式同步狀態獲取與釋放

共享式允許同一時刻多個執行緒同時獲取同步狀態。 共享式同步狀態的acquireShared（int arg）可以共享的獲得同步狀態，當tryAcquaire方法返回值大於0，表示能夠獲得同步狀態，否則呼叫doAcquireShare進行自旋該方法程式碼如下：
釋放的程式碼如下： 、

重入鎖

前面我們寫的Mutex就是一個不可重入的鎖，重入的鎖就是當一個執行緒A獲得一個鎖之後，再次呼叫lock（）方法，不會把自己阻塞，而是在當前鎖繼續加一。釋放鎖的時候，也會每釋放一次就讓state加一，直到加到0表示釋放完成。 公平鎖和非公平鎖：在研究衝入鎖的時候，ReentrantLokc實現了兩個方法。TryAcquire是公平的鎖，nonfairTryAcquire（）方法是非公平鎖。二者的區別是，公平鎖能夠是能夠按照進入的佇列順序來進行鎖的獲取的，而非公平鎖不管這個。可以通過呼叫ReentrantLock（Boolean flag）來設定開啟。設定flag為true是公平鎖，否則為非公平鎖。預設是非公平鎖

讀寫鎖ReentrantReadWriteLock

讀寫鎖不是實現的lock介面，因此不能用多型的方式例項化ReentrantReadWriteLock。讀寫鎖能夠獲得讀鎖和寫鎖。讀鎖是共享的，寫鎖是排除的。

LockSupport工具

LockSupport工具定義了一組的公共靜態方法，提供了基本的執行緒阻塞和喚醒功能。

Condition介面

condition介面也實現了類似的像監控器一樣的方法。與lock配合可以實現等待通知模式。