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

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.

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

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

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

public class Counter{
  private int count = 0;

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

以下的Counter類用Lock代替synchronized 達(dá)到同樣的目的：
lock() 方法會(huì)對(duì) Lock 實(shí)例對(duì)象進(jìn)行加鎖，因此所有其他對(duì)該對(duì)象調(diào)用 lock() 方法的線程都會(huì)被阻塞，直到該 Lock 對(duì)象的 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è)計(jì)的？

一個(gè)Lock類的簡(jiǎn)單實(shí)現(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.

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

    公平鎖實(shí)現(xiàn)機(jī)制：為每一個(gè)線程創(chuàng)建一個(gè)專屬鎖對(duì)象（而非多個(gè)線程共享一個(gè)對(duì)象，來wait/notify()），然后用一個(gè)隊(duì)列來管理這些鎖對(duì)象，嘗試加鎖的線程會(huì)在各自的對(duì)象上等待，當(dāng)一個(gè)線程unlock的時(shí)候，只通知隊(duì)列頭的鎖對(duì)象，以喚醒其對(duì)應(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();
    }
  }
}