線程鎖和條件對象

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

在Java中為了解決并發(fā)的數(shù)據(jù)訪問問題，一般使用鎖這個概念來解決。

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

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

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();確保只有一個線程進入臨界區(qū)，一旦一個線程進入之后，會獲得鎖對象，其他線程無法通過lock語句。當其他線程調(diào)用lock時，它們會被阻塞，知道第一個線程釋放鎖對象。

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

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

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

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

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

synchronized關鍵字

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

舉個例子:

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

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

Conditional條件對象

通常，線程拿到鎖對象之后，卻發(fā)現(xiàn)需要滿足某一條件才能繼續(xù)向下執(zhí)行。

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

舉例：

public void Transfer(int from, int to, double amount) {
  if (Accounts[from] > amount)//系統(tǒng)在結(jié)束判斷之后被剝奪運行權,然后賬戶通過網(wǎng)銀轉(zhuǎn)出所有錢,銀行涼涼
    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();
  }
}

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

這個問題如何解決呢？

條件對象登場！

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，表示余額充足的意思。

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

你說為啥不直接通知當前線程？不行，可以調(diào)用signal方法只通知一個線程，但是如果這個線程操作的賬戶還是沒錢（不是轉(zhuǎn)賬給這個賬戶的情況），那這個線程又進入等待了，這時候已經(jīng)沒有線程能通知其他線程了，程序死鎖，所以還是用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對象的鎖，這種鎖是一個特殊的鎖，在上面的代碼中，創(chuàng)建這個Object類對象只是單純用來使用其持有的鎖.

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

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

監(jiān)視器的概念

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

監(jiān)視器具有以下特性:

1.監(jiān)視器是只包含私有域的類

2.每個監(jiān)視器對象都有一個相關的鎖

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

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

你也可以自己創(chuàng)建一個監(jiān)視器類，只要符合以上的要求即可。

其實我們使用的synchronized關鍵字就是使用了monitor來實現(xiàn)加鎖解鎖，所以又被稱為內(nèi)部鎖。因為Object類實現(xiàn)了監(jiān)視器，所以對象又被內(nèi)置于任何一個對象之中。這就是我們?yōu)槭裁纯梢允褂胹ynchronized(locker)的方式鎖定一個代碼塊了，其實只是用到了locker對象中內(nèi)置的monitor而已。每一個對象的monitor類又是唯一的，所以就是唯一的許可證，拿到許可證的線程才可以執(zhí)行，執(zhí)行完后釋放對象的monitor才可以被其他線程獲取。

舉個例子:

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

它在字節(jié)碼文件中會被編譯為:

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的金額都不足以進行轉(zhuǎn)賬，所以兩個線程都阻塞了，這種狀態(tài)就叫死鎖（deadlock），如果所有線程死鎖，程序就卡死了。

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

鎖測試和超時

線程在調(diào)用lock方法獲得另一個線程持有的鎖的時候，很可能發(fā)生阻塞。應該更加謹慎的申請鎖，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
}

也可以給其指定超時參數(shù)，單位有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方法不能被中斷，如果一個線程在調(diào)用了lock方法后等待鎖的時候被中斷，中斷線程在獲得鎖之前一直處于阻塞狀態(tài)。

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

讀/寫鎖

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

private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock():

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

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