摘要：執(zhí)行會重新將設(shè)置為，并且通知喚醒其中一個若有的話在方法中調(diào)用了函數(shù)而處于等待狀態(tài)的線程。除此之外，我們需要記錄同一個線程重復對一個鎖對象加鎖的次數(shù)。競爭失敗的線程處于就緒狀態(tài)，長期競爭失敗的線程就會饑餓。

tutorials site

  
Locks (and other more advanced synchronization mechanisms) are created using synchronized blocks, so it is not like we can get totally rid of the synchronized keyword.

  鎖的實現(xiàn)是利用synchonized， wait()，notify()方法實現(xiàn)的。所以不可以認為鎖可以完全脫離synchonized實現(xiàn)。

Java包 JUC java.util.concurrent.locks 包括了很多l(xiāng)ock接口的實現(xiàn)了類，這些類足夠使用。
但是需要知道如何使用它們，以及這些類背后的理論。JUC包教程

用synchonized：可以保證在同一時間只有一個線程可以執(zhí)行 return ++count:

public class Counter{
  private int count = 0;

  public int inc(){
    synchronized(this){
      return ++count;
    }
  }
}

以下的Counter類用Lock代替synchronized 達到同樣的目的：
lock() 方法會對 Lock 實例對象進行加鎖，因此所有其他對該對象調(diào)用 lock() 方法的線程都會被阻塞，直到該 Lock 對象的 unlock() 方法被調(diào)用。

public class Counter{
  private Lock lock = new Lock();
  private int count = 0;

  public int inc(){
    lock.lock();
    int newCount = ++count;
    lock.unlock();
    return newCount;
  }
}

那么問題來了， Lock類是怎么設(shè)計的？

一個Lock類的簡單實現(xiàn)：

javapublic class Lock{
  private boolean isLocked = false;

  public synchronized void lock() throws InterruptedException{
    while(isLocked){
      wait();
    }
    isLocked = true;
  }

  public synchronized void unlock(){
    isLocked = false;
    notify();
  }
}

javapublic class Reentrant2{
    Lock lock = new Lock();

    public outer(){
        lock.lock();
        inner();
        lock.unlock();
    }

    public synchronized inner(){
        lock.lock();
        //do something
        lock.unlock();
    }
}

javapublic class Lock{
    boolean isLocked = false;
    Thread  lockedBy = null;
    int lockedCount = 0;

    public synchronized void lock()
        throws InterruptedException{
        Thread callingThread =
            Thread.currentThread();
        while(isLocked && lockedBy != callingThread){
            wait();
        }
        isLocked = true;
        lockedCount++;
        lockedBy = callingThread;
  }

    public synchronized void unlock(){
        if(Thread.curentThread() ==
            this.lockedBy){
            lockedCount--;

            if(lockedCount == 0){
                isLocked = false;
                notify();
            }
        }
    }

    ...
}

 Starvation and Fairness 饑餓和公平

  
Java"s synchronized code blocks can be another cause of starvation.

  
每一個調(diào)用 lock() 的線程都會進入一個隊列，當解鎖后，只有隊列里的第一個線程 （隊首）被允許鎖住 Fairlock 實例，所有其它的線程都將處于等待狀態(tài)，直到他們處于隊列頭部。

    公平鎖實現(xiàn)機制：為每一個線程創(chuàng)建一個專屬鎖對象（而非多個線程共享一個對象，來wait/notify()），然后用一個隊列來管理這些鎖對象，嘗試加鎖的線程會在各自的對象上等待，當一個線程unlock的時候，只通知隊列頭的鎖對象，以喚醒其對應(yīng)的線程

javapublic class FairLock {
    private boolean           isLocked       = false;
    private Thread            lockingThread  = null;
    private List waitingThreads =
            new ArrayList();

  public void lock() throws InterruptedException{
    QueueObject queueObject           = new QueueObject();
    boolean     isLockedForThisThread = true;
    synchronized(this){
        waitingThreads.add(queueObject);
    }

    while(isLockedForThisThread){
      synchronized(this){
        isLockedForThisThread =
            isLocked || waitingThreads.get(0) != queueObject;
        if(!isLockedForThisThread){
          isLocked = true;
           waitingThreads.remove(queueObject);
           lockingThread = Thread.currentThread();
           return;
         }
      }
      try{
        queueObject.doWait();
      }catch(InterruptedException e){
        synchronized(this) { waitingThreads.remove(queueObject); }
        throw e;
      }
    }
  }

  public synchronized void unlock(){
    if(this.lockingThread != Thread.currentThread()){
      throw new IllegalMonitorStateException(
        "Calling thread has not locked this lock");
    }
    isLocked      = false;
    lockingThread = null;
    if(waitingThreads.size() > 0){
      waitingThreads.get(0).doNotify();
    }
  }
}