【Java併發編程實戰】– 使用鎖實現同步 lock_1

1、概述

  Lock是 java.util.concurrent.locks 包下的接口，Lock 實現提供了比使用synchronized 方法和語句可得到的更普遍的鎖定操做，它能以更優雅的方式處理線程同步問題。

------------------------------------------------------------------------------------------------------------

lock 產生的背景：

採用synchronized關鍵字來實現同步的話，就會致使一個問題：若是多個線程都只是進行讀操做，因此當一個線程在進行讀操做時，其餘線程只能等待沒法進行讀操做。

所以就須要一種機制來使得多個線程都只是進行讀操做時，線程之間不會發生衝突，經過Lock就能夠辦到。另外，經過Lock能夠知道線程有沒有成功獲取到鎖。這個是 synchronized 沒法辦到的。

------------------------------------------------------------------------------------------------------------

sychronized 與 lock 的 比較：

一、Lock不是Java語言內置的，synchronized是Java語言的關鍵字，所以是內置特性。Lock是一個類，經過這個類能夠實現同步訪問；

二、Lock和synchronized有一點很是大的不一樣，採用synchronized不須要用戶去手動釋放鎖，當synchronized方法或者synchronized代碼塊執行完以後，系統會自動讓線程釋放對鎖的佔用；而Lock則必需要用戶去手動釋放鎖，若是沒有主動釋放鎖，就有可能致使出現死鎖現象。

------------------------------------------------------------------------------------------------------------

須要注意的地方：

用 sychronized 修飾的方法或者語句塊在代碼執行完以後鎖 自動釋放，而用 Lock 須要咱們手動釋放鎖，因此爲了保證鎖最終被釋放(發生異常狀況)，要把互斥區放在 try 內，釋放鎖放在 finally 內。

------------------------------------------------------------------------------------------------------------

2、實現

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 打印隊列類
public class PrintQueue {

	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
	//聲明並實例化一個鎖對象
	private final Lock queueLock = new ReentrantLock();
	
	//實現 打印方法
	public void printJob(Object doc){
		 queueLock.lock(); // 獲取鎖對象的控制
		 try {
			System.out.println(Thread.currentThread().getName() + " - printJob 正在打印,請等待...,時間：" + sdf.format(new Date()));
			TimeUnit.SECONDS.sleep(2);
		 } catch (InterruptedException e) {
			e.printStackTrace();
		 } finally{
			queueLock.unlock(); // 釋放鎖對象的控制.(通常是 finally 中手動釋放)
		 }
	}
	
}

import java.text.SimpleDateFormat;
import java.util.Date;

public class Job implements Runnable{

	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
	
	private PrintQueue printQueue;
	public Job(PrintQueue printQueue){
		this.printQueue = printQueue;
	}
	
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName() + "準備打印...,時間：" + sdf.format(new Date()));
		printQueue.printJob(new Object()); // 發送 打印任務.
		System.out.println(Thread.currentThread().getName() + "完成打印...,時間：" + sdf.format(new Date()));
	}

}

public class TestJob {

	public static void main(String[] args) {
		PrintQueue printQueue = new PrintQueue();
		for(int i=0;i<3;i++){
			Thread thread = new Thread(new Job(printQueue)); //3個線程建立3個打印工做
			thread.start();
		}
	}
	
	/** console 結果：
	 *  Thread-1準備打印...,時間：2017-09-08 10:43:06
		Thread-2準備打印...,時間：2017-09-08 10:43:06
		Thread-0準備打印...,時間：2017-09-08 10:43:06
		Thread-1 - printJob 正在打印,請等待...,時間：2017-09-08 10:43:06
		Thread-1完成打印...,時間：2017-09-08 10:43:08
		Thread-2 - printJob 正在打印,請等待...,時間：2017-09-08 10:43:08
		Thread-2完成打印...,時間：2017-09-08 10:43:10
		Thread-0 - printJob 正在打印,請等待...,時間：2017-09-08 10:43:10
		Thread-0完成打印...,時間：2017-09-08 10:43:12
	 */
}

分析：

示例 主要部分是打印隊列類 PrintQueue中的 printJob()方法。

使用 鎖實現了一個臨界區，而且保證同一個時間只有一個執行線程訪問這個臨界區時，必須建立 ReentrantLock 對象。在這個臨界區的開始，必須經過 lock() 方法 獲取對鎖的控制。當線程A 訪問這個方法時，若是沒有其餘線程獲取對這個鎖的控制，lock() 方法將讓線程 A 得到 鎖而且容許 它當即執行 臨界區代碼。不然，若是其餘線程 B 正在執行這個鎖保護的臨界區代碼，lock() 方法將讓線程 A 休眠直到 線程 B 執行完臨界區的代碼。

在線程 離開臨界區的時候，必須使用 unlock()方法來 釋放它持有的鎖，以讓其餘線程來訪問臨界區。若是在離開臨界區的時候沒有調用 unlock() 方法，其餘線程將永久地等待，從而致使死鎖情景。若是在 臨界區使用了 try-catch 塊，記得必須將 unlock() 方法 放入 finally部分。

3、經常使用方法

 一、lock()  

      若是鎖已被其餘線程獲取，則進行等待。若是採用 Lock，必須主動去釋放鎖，而且在發生異常時，不會自動釋放鎖。所以，通常來講，使用Lock必須在 try…catch… 塊中進行，而且將釋放鎖的操做放在 finally 塊中進行，以保證鎖必定被被釋放，防止死鎖的發生。

Lock lock = ...;
lock.lock();
try{
    //處理任務
}catch(Exception ex){

}finally{
    lock.unlock();   //釋放鎖
}

二、tryLock() & tryLock(long time, TimeUnit unit)

tryLock() 方法是有返回值的，它表示用來嘗試獲取鎖，若是獲取成功，則返回true；若是獲取失敗（即鎖已被其餘線程獲取），則返回false，也就是說，這個方法不管如何都會當即返回（在拿不到鎖時不會一直在那等待）。

tryLock (long time, TimeUnit unit) 方法和 tryLock() 方法是相似的，只不過區別在於這個方法在拿不到鎖時會等待必定的時間，在時間期限以內若是還拿不到鎖，就返回false，同時能夠響應中斷。若是一開始拿到鎖或者在等待期間內拿到了鎖，則返回 true。

Lock lock = ...;
if(lock.tryLock()) {
     try{
         //處理任務
     }catch(Exception ex){

     }finally{
         lock.unlock();   //釋放鎖
     } 
}else {
    //若是不能獲取鎖，則直接作其餘事情
}

4、Lock和synchronized的選擇

總的來講，Lock和synchronized有如下幾點不一樣：

一、 Lock是一個接口，是JDK層面的實現；而synchronized是Java中的關鍵字，是Java的內置特性，是JVM層面的實現；

二、 synchronized 在發生異常時，會自動釋放線程佔有的鎖，所以不會致使死鎖現象發生；而Lock在發生異常時，若是沒有主動經過unLock()去釋放鎖，則極可能形成死鎖現象，所以使用Lock時須要在finally塊中釋放鎖；

三、Lock 可讓等待鎖的線程響應中斷，而使用synchronized時，等待的線程會一直等待下去，不可以響應中斷；

四、 經過Lock能夠知道有沒有成功獲取鎖，而synchronized卻沒法辦到；

五、 Lock能夠提升多個線程進行 讀操做 的效率。

在性能上來講，若是競爭資源不激烈，二者的性能是差很少的。而當競爭資源很是激烈時（即有大量線程同時競爭），此時 Lock 的性能要遠遠優於synchronized。因此說，在具體使用時要根據適當狀況選擇。