詳解Java同步—線程鎖和條件對象

線程鎖和條件對象

在大多數多線程應用中，都是兩個及以上線程需要共享對同一數據的存取，所以有可能出現兩個線程同時訪問同一個資源的情況，這種情況叫做：競爭條件。

在Java中為了解決并發的數據訪問問題，一般使用鎖這個概念來解決。

有幾種機制防止代碼收到并發訪問的干擾：

1.synchronized關鍵字（自動創建一個鎖及相關的條件）

2.ReentrantLock類+Java.util.concurrent包中的lock接口（在Java5.0的時候引入）

ReentrantLock的使用

public void Method() {
    boolean flag = false;//標識條件
    ReentrantLock locker = new ReentrantLock();
    locker.lock();//開啟線程鎖
    try {
      //do some work...
    } catch (Exception ex) {

    } finally {
      locker.unlock();//解鎖線程
    }
  }

locker.lock();確保只有一個線程進入臨界區，一旦一個線程進入之后，會獲得鎖對象，其他線程無法通過lock語句。當其他線程調用lock時，它們會被阻塞，知道第一個線程釋放鎖對象。

locker.unlock();解鎖操作，一定要放到finally里，因為如果try語句里出了問題，鎖必須被釋放，否則其他線程將永遠被阻塞

因為系統會隨機為線程分配資源，所以在線程獲得鎖對象之后，可能被系統剝奪運行權，這時候其他線程來訪問，但是發現有鎖，進不去，只能等拿到鎖對象的線程把里面的代碼執行完畢后，釋放鎖，第二個線程才能運行。

假設說做一個銀行轉賬的功能，線程鎖操作應該定義在銀行類的轉賬方法里，因為這樣每個銀行對象都有一個鎖對象，兩個線程訪問一個銀行對象的時候，那么鎖以串行方式提供服務。但是，如果每個線程訪問不同的銀行對象，每個線程都會得到不同的鎖對象，彼此之間不會沖突，所以就不會造成不必要的線程阻塞。

鎖是可重入的，線程可以重復獲得已經持有的鎖，鎖通過一個持有數量計數來跟蹤對lock方法的嵌套使用。

假設說，一個線程獲得鎖之后，要執行A方法，但是A方法里面又調用了B方法，這時候這個線程獲得了兩個鎖對象，當線程執行B方法的時候，也會被鎖死，防止其他線程亂入，當B方法執行完畢后，鎖對象變成了一個，當A方法也執行完畢的時候，鎖對象變成了0個，線程釋放鎖。

synchronized關鍵字

前面我們講了ReentrantLock鎖對象的使用，但是在系統里面我們不一定要使用ReentrantLock鎖，Java中還提供了一個內部的隱式鎖，關鍵字是synchronized.

舉個例子:

public synchronized void Method() {
  //do some work...
}

只需要在返回值前面加上synchronized鎖，就會實現上面ReentrantLock鎖同樣的效果.

Conditional條件對象

通常，線程拿到鎖對象之后，卻發現需要滿足某一條件才能繼續向下執行。

拿銀行程序來舉例子，我們需要轉賬方賬戶有足夠的資金才能轉出到目標賬戶，這時候需要用到ReentrantLock對象，因為如果我們已經完成轉賬方賬戶有足夠的資金的判斷之后，線程被其他線程中斷，等其他線程執行完之后，轉賬方的錢又沒有了足夠的資金，這時候因為系統已經完成了判斷，所以會繼續向下執行，然后銀行系統就會出現問題。

舉例：

public void Transfer(int from, int to, double amount) {
  if (Accounts[from] > amount)//系統在結束判斷之后被剝奪運行權,然后賬戶通過網銀轉出所有錢,銀行涼涼
    DoTransfer(from, to, amount);
}

這時候我們就需要使用ReentrantLock對象了，我們修改一下代碼：

public void Transfer(int from, int to, double amount) {
  ReentrantLock locker = new ReentrantLock();
  locker.lock();
  try {
    while (Accounts[from] < amount) {
      //等待有足夠的錢
    }
    DoTransfer(from, to, amount);
  } catch (Exception ex) {
    ex.printStackTrace();
  } finally {
    locker.unlock();
  }
}

但是這樣又有了問題，當前線程獲取了鎖對象之后，開始執行代碼，發現錢不夠，進入等待狀態，然后其他線程又因為鎖的原因無法給該賬戶轉賬，就會一直進入等待狀態。

這個問題如何解決呢？

條件對象登場！

public void Transfer(int from, int to, double amount) {
  ReentrantLock locker = new ReentrantLock();
  Condition sufficientFunds = locker.newCondition();//條件對象，
  lock.lock();
  try {
    while (Accounts[from] < amount) {
      sufficientFunds.await();
      //等待有足夠的錢
    }
    DoTransfer(from, to, amount);
    sufficientFunds.signalAll();
  } catch (Exception ex) {
    ex.printStackTrace();
  } finally {
    locker.unlock();
  }
}

條件對象的關鍵字是:Condition，一個鎖對象可以有一個或多個相關的條件對象。可以通過鎖對象.newCondition方法獲得一個條件對象.

一般關于條件對象的命名需要能夠反映它表達的條件的名字，所以在這里我們叫他sufficientFund，表示余額充足的意思。

在進入鎖之前，我們創建一個條件，然后如果金額不足，在這里調用條件對象的await方法，通知系統當前線程進入掛起狀態，讓其他線程執行。這樣你這次調用會被鎖定，然后系統可以再次調用該方法給其他賬戶轉賬，當每一次轉賬完成后，執行轉賬操作的線程在底部調用signalAll通知所有線程可以繼續運行了，因為我們有可能是轉足夠的錢給當前賬戶，這時候有可能該線程會繼續執行（不一定是你，是通知所有線程，如果通知的線程還是不符合條件，會繼續調用await方法，并完成轉賬操作，然后通知其他掛起的線程。

你說為啥不直接通知當前線程？不行，可以調用signal方法只通知一個線程，但是如果這個線程操作的賬戶還是沒錢（不是轉賬給這個賬戶的情況），那這個線程又進入等待了，這時候已經沒有線程能通知其他線程了，程序死鎖，所以還是用signal比較保險。

以上是使用ReentrantLock+Condition對象，那你說我要是使用synchronized隱式鎖怎么辦？

也可以，而且不需要

public void Transfer(int from, int to, double amount) {
   while (Accounts[from] < amount) {
      wait();//這個wait方法是定義在Object類里面的，可以直接用，和條件對象的await一樣，掛起線程
      //等待有足夠的錢
    }
    DoTransfer(from, to, amount);
    notifyAll();//通知其他掛起的線程
}

Object類里面定義了wait、notifyAll、notify方法，對應await、signalAll和signal方法，用來操作隱式鎖，synchronized只能有一個條件，而ReentrantLock顯式聲明的鎖可以用綁定多個Condition條件.

同步塊

除了我們上面講的兩種獲取線程鎖的方式，還有另外一種機制獲得鎖，這種方式比較特殊，叫做同步塊:

Object locker = new Object();
synchronized (locker) {
  //do some work
}

//也可以直接鎖當前類的對象
sychronized(this){
  //do some work
}

以上代碼會獲得Object類型locker對象的鎖，這種鎖是一個特殊的鎖，在上面的代碼中，創建這個Object類對象只是單純用來使用其持有的鎖.

這種機制叫做同步塊，應用場景也很廣：有的時候，我們并不是整個一個方法都需要同步，只是方法里的部分代碼塊需要同步，這種情況下，我們如果將這個方法聲明為synchronized，尤其是方法很大的時候，會造成很大的資源浪費。所以在這種情況下我們可以使用synchronized關鍵字來聲明同步塊:

public void Method() {
  //do some work without synchronized
  synchronized (this) {
    //do some synchronized operation
  }
}

監視器的概念

鎖和條件是同步中一個很重要的工具，但是它們并不是面向對象的。多年來，Java的研究人員努力尋找一種方法，可以在不需要考慮如何加鎖的情況下，就能保證多線程的安全性。最成功的的一個解決方案叫做monitor監視器，這個對象內置于每一個Object變量中，相當于一個許可證。拿到許可證就可以進行操作，沒有拿到則需要阻塞等待。

監視器具有以下特性:

1.監視器是只包含私有域的類

2.每個監視器對象都有一個相關的鎖

3.使用監視器對象的鎖對所有的方法進行加鎖（舉個例子:如果調用obj.Method方法，obj對象的鎖會在方法調用的時候自動獲得，當方法結束或返回之后會自動釋放該鎖。因為所有的域都是私有的，這樣可以確保一個線程在操作類對象的時候，沒有其他線程可以訪問里面的域）

4.該鎖對象可以有任意多個相關條件

你也可以自己創建一個監視器類，只要符合以上的要求即可。

其實我們使用的synchronized關鍵字就是使用了monitor來實現加鎖解鎖，所以又被稱為內部鎖。因為Object類實現了監視器，所以對象又被內置于任何一個對象之中。這就是我們為什么可以使用synchronized(locker)的方式鎖定一個代碼塊了，其實只是用到了locker對象中內置的monitor而已。每一個對象的monitor類又是唯一的，所以就是唯一的許可證，拿到許可證的線程才可以執行，執行完后釋放對象的monitor才可以被其他線程獲取。

舉個例子:

synchronized (this) {
  //do some synchronized operation
}

它在字節碼文件中會被編譯為:

monitorenter;//get monitor，enter the synchronized block
      //do some synchronized operation
monitorexit;//leavel the synchronized block,release the monitor

死鎖

雖然有了線程可以保證原子性，但是鎖和條件不能解決多線程中的所有問題，舉個例子:

賬戶1余額：200

賬戶2余額：300

線程1：賬戶1→賬戶2（300）

線程2：賬戶2→賬戶1（400）

因為線程1和線程2的金額都不足以進行轉賬，所以兩個線程都阻塞了，這種狀態就叫死鎖（deadlock），如果所有線程死鎖，程序就卡死了。

為什么傾向于使用signalAll和notifyAll方式，如果假設使用signal和notify，

鎖測試和超時

線程在調用lock方法獲得另一個線程持有的鎖的時候，很可能發生阻塞。應該更加謹慎的申請鎖，tryLock方法試圖申請一個鎖，如果申請成功，返回true，否則，立刻返回false，線程就會離開去做別的事，而不是被阻塞等待鎖對象。

語法:

ReentrantLock locker = new ReentrantLock();
if (locker.tryLock()) {
  try {
    //do some work
  } catch (Exception ex) {
    ex.printStackTrace();
  } finally {
    locker.unlock();
  }
} else {
  //do other work
}

也可以給其指定超時參數，單位有SECONDS、MILLISECONDS、MICROSEONDS和MANOSECONDS.

ReentrantLock locker = new ReentrantLock();
if (locker.tryLock(1000, TimeUnit.MILLISECONDS)) {
  try {
    //do some work
  } catch (Exception ex) {
    ex.printStackTrace();
  } finally {
    locker.unlock();
  }
} else {
  //do other work
}

lock方法不能被中斷，如果一個線程在調用了lock方法后等待鎖的時候被中斷，中斷線程在獲得鎖之前一直處于阻塞狀態。

如果帶有超時參數的tryLock方法,那么如果等待期間線程被中斷，會拋出InterruptedException異常，這是一個很好的特性，允許程序打破死鎖。

讀/寫鎖

ReentrantLock類屬于java.util.concurrent.locks包，這個包底下還有一個ReentrantReaderWriterLock類，如果使用多線程對數據讀的操作很多，但是寫的操作很少的話，可以使用這個類。

private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock():

public void Read() {
  Lock readLocker = rwl.readLock();//創建讀取鎖對象
  readLocker.lock();//使用讀取鎖對象加鎖
  try {
    //do some work
  } catch (Exception ex) {
    ex.printStackTrace();
  } finally {
    readLocker.unlock();
  }
}

public void Write() {
  Lock writeLocker = rwl.writeLock();//創建寫入鎖對象
  writeLocker.lock();//使用寫入鎖對象加鎖
  try {
    //do some work
  } catch (Exception ex) {
    ex.printStackTrace();
  } finally {
    writeLocker.unlock();
  }
}