API說明

實現自定義同步器時，需要使用同步器提供的getState()、setState()和compareAndSetState()方法來操縱狀態的變遷。

實現這些方法必須是非阻塞而且是執行緒安全的，推薦使用該同步器的父類java.util.concurrent.locks.AbstractOwnableSynchronizer來設定當前的執行緒。
開始提到同步器內部基於一個FIFO佇列，對於一個獨佔鎖的獲取和釋放有以下偽碼可以表示。
獲取一個排他鎖。

釋放一個排他鎖。

public class Mutex implements Lock, java.io.Serializable {
	   // 內部類，自定義同步器
	   private static class Sync extends AbstractQueuedSynchronizer {
	     // 是否處於佔用狀態
	     protected boolean isHeldExclusively() {
	       return getState() == 1;
	     }
	     // 當狀態為0的時候獲取鎖
	     public boolean tryAcquire(int acquires) {
	       assert acquires == 1; // Otherwise unused
	       if (compareAndSetState(0, 1)) {
	         setExclusiveOwnerThread(Thread.currentThread());
	         return true;
	       }
	       return false;
	     }
	     // 釋放鎖，將狀態設定為0
	     protected boolean tryRelease(int releases) {
	       assert releases == 1; // Otherwise unused
	       if (getState() == 0) throw new IllegalMonitorStateException();
	       setExclusiveOwnerThread(null);
	       setState(0);
	       return true;
	     }
	     // 返回一個Condition，每個condition都包含了一個condition佇列
	     Condition newCondition() { return new ConditionObject(); }
	   }
	   // 僅需要將操作代理到Sync上即可
	   private final Sync sync = new Sync();
	   public void lock()                { sync.acquire(1); }
	   public boolean tryLock()          { return sync.tryAcquire(1); }
	   public void unlock()              { sync.release(1); }
	   public Condition newCondition()   { return sync.newCondition(); }
	   public boolean isLocked()         { return sync.isHeldExclusively(); }
	   public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
	   public void lockInterruptibly() throws InterruptedException {
	     sync.acquireInterruptibly(1);
	   }
	   public boolean tryLock(long timeout, TimeUnit unit)
	       throws InterruptedException {
	     return sync.tryAcquireNanos(1, unit.toNanos(timeout));
	   }
	 }
 

實現分析

加鎖：public final void acquire(int arg)

該方法以排他的方式獲取鎖，對中斷不敏感，完成synchronized語義。

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

 protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }