簡(jiǎn)單使用Lock鎖

    Java 5中引入了新的鎖機(jī)制——java.util.concurrent.locks中的顯式的互斥鎖：Lock接口，它提供了比synchronized更加廣泛的鎖定操作。Lock接口有3個(gè)實(shí)現(xiàn)它的類(lèi)：ReentrantLock、ReetrantReadWriteLock.ReadLock和ReetrantReadWriteLock.WriteLock，即重入鎖、讀鎖和寫(xiě)鎖。lock必須被顯式地創(chuàng)建、鎖定和釋放，為了可以使用更多的功能，一般用ReentrantLock為其實(shí)例化。為了保證鎖最終一定會(huì)被釋放（可能會(huì)有異常發(fā)生），要把互斥區(qū)放在try語(yǔ)句塊內(nèi)，并在finally語(yǔ)句塊中釋放鎖，尤其當(dāng)有return語(yǔ)句時(shí)，return語(yǔ)句必須放在try字句中，以確保unlock（）不會(huì)過(guò)早發(fā)生，從而將數(shù)據(jù)暴露給第二個(gè)任務(wù)。因此，采用lock加鎖和釋放鎖的一般形式如下：

  Lock lock = new ReentrantLock();//默認(rèn)使用非公平鎖，如果要使用公平鎖，需要傳入?yún)?shù)true
  ........
  lock.lock();
  try {
   //更新對(duì)象的狀態(tài)
   //捕獲異常，必要時(shí)恢復(fù)到原來(lái)的不變約束
  //如果有return語(yǔ)句，放在這里
 } finally {
   lock.unlock();  //鎖必須在finally塊中釋放
 }

ReetrankLock與synchronized比較

  性能比較

  在JDK1.5中，synchronized是性能低效的。因?yàn)檫@是一個(gè)重量級(jí)操作，它對(duì)性能最大的影響是阻塞的是實(shí)現(xiàn)，掛起線程和恢復(fù)線程的操作都需要轉(zhuǎn)入內(nèi)核態(tài)中完成，這些操作給系統(tǒng)的并發(fā)性帶來(lái)了很大的壓力。相比之下使用Java提供的Lock對(duì)象，性能更高一些。Brian Goetz對(duì)這兩種鎖在JDK1.5、單核處理器及雙Xeon處理器環(huán)境下做了一組吞吐量對(duì)比的實(shí)驗(yàn)，發(fā)現(xiàn)多線程環(huán)境下，synchronized的吞吐量下降的非常嚴(yán)重，而ReentrankLock則能基本保持在同一個(gè)比較穩(wěn)定的水平上。但與其說(shuō)ReetrantLock性能好，倒不如說(shuō)synchronized還有非常大的優(yōu)化余地，于是到了JDK1.6，發(fā)生了變化，對(duì)synchronize加入了很多優(yōu)化措施，有自適應(yīng)自旋，鎖消除，鎖粗化，輕量級(jí)鎖，偏向鎖等等。導(dǎo)致在JDK1.6上synchronize的性能并不比Lock差。官方也表示，他們也更支持synchronize，在未來(lái)的版本中還有優(yōu)化余地，所以還是提倡在synchronized能實(shí)現(xiàn)需求的情況下，優(yōu)先考慮使用synchronized來(lái)進(jìn)行同步。

   下面淺析以下兩種鎖機(jī)制的底層的實(shí)現(xiàn)策略。

    互斥同步最主要的問(wèn)題就是進(jìn)行線程阻塞和喚醒所帶來(lái)的性能問(wèn)題，因而這種同步又稱(chēng)為阻塞同步，它屬于一種悲觀的并發(fā)策略，即線程獲得的是獨(dú)占鎖。獨(dú)占鎖意味著其他線程只能依靠阻塞來(lái)等待線程釋放鎖。而在CPU轉(zhuǎn)換線程阻塞時(shí)會(huì)引起線程上下文切換，當(dāng)有很多線程競(jìng)爭(zhēng)鎖的時(shí)候，會(huì)引起CPU頻繁的上下文切換導(dǎo)致效率很低。synchronized采用的便是這種并發(fā)策略。

    隨著指令集的發(fā)展，我們有了另一種選擇：基于沖突檢測(cè)的樂(lè)觀并發(fā)策略，通俗地講就是先進(jìn)性操作，如果沒(méi)有其他線程爭(zhēng)用共享數(shù)據(jù)，那操作就成功了，如果共享數(shù)據(jù)被爭(zhēng)用，產(chǎn)生了沖突，那就再進(jìn)行其他的補(bǔ)償措施（最常見(jiàn)的補(bǔ)償措施就是不斷地重拾，直到試成功為止），這種樂(lè)觀的并發(fā)策略的許多實(shí)現(xiàn)都不需要把線程掛起，因此這種同步被稱(chēng)為非阻塞同步。ReetrantLock采用的便是這種并發(fā)策略。

    在樂(lè)觀的并發(fā)策略中，需要操作和沖突檢測(cè)這兩個(gè)步驟具備原子性，它靠硬件指令來(lái)保證，這里用的是CAS操作（Compare and Swap）。JDK1.5之后，Java程序才可以使用CAS操作。我們可以進(jìn)一步研究ReentrantLock的源代碼，會(huì)發(fā)現(xiàn)其中比較重要的獲得鎖的一個(gè)方法是compareAndSetState，這里其實(shí)就是調(diào)用的CPU提供的特殊指令?，F(xiàn)代的CPU提供了指令，可以自動(dòng)更新共享數(shù)據(jù)，而且能夠檢測(cè)到其他線程的干擾，而compareAndSet() 就用這些代替了鎖定。這個(gè)算法稱(chēng)作非阻塞算法，意思是一個(gè)線程的失敗或者掛起不應(yīng)該影響其他線程的失敗或掛起。

    Java 5中引入了注入AutomicInteger、AutomicLong、AutomicReference等特殊的原子性變量類(lèi)，它們提供的如：compareAndSet（）、incrementAndSet（）和getAndIncrement（）等方法都使用了CAS操作。因此，它們都是由硬件指令來(lái)保證的原子方法。

   用途比較

    基本語(yǔ)法上，ReentrantLock與synchronized很相似，它們都具備一樣的線程重入特性，只是代碼寫(xiě)法上有點(diǎn)區(qū)別而已，一個(gè)表現(xiàn)為API層面的互斥鎖（Lock），一個(gè)表現(xiàn)為原生語(yǔ)法層面的互斥鎖（synchronized）。ReentrantLock相對(duì)synchronized而言還是增加了一些高級(jí)功能，主要有以下三項(xiàng)：

    1、等待可中斷：當(dāng)持有鎖的線程長(zhǎng)期不釋放鎖時(shí)，正在等待的線程可以選擇放棄等待，改為處理其他事情，它對(duì)處理執(zhí)行時(shí)間非常上的同步塊很有幫助。而在等待由synchronized產(chǎn)生的互斥鎖時(shí)，會(huì)一直阻塞，是不能被中斷的。

    2、可實(shí)現(xiàn)公平鎖：多個(gè)線程在等待同一個(gè)鎖時(shí)，必須按照申請(qǐng)鎖的時(shí)間順序排隊(duì)等待，而非公平鎖則不保證這點(diǎn)，在鎖釋放時(shí)，任何一個(gè)等待鎖的線程都有機(jī)會(huì)獲得鎖。synchronized中的鎖時(shí)非公平鎖，ReentrantLock默認(rèn)情況下也是非公平鎖，但可以通過(guò)構(gòu)造方法ReentrantLock（ture）來(lái)要求使用公平鎖。

    3、鎖可以綁定多個(gè)條件：ReentrantLock對(duì)象可以同時(shí)綁定多個(gè)Condition對(duì)象（名曰：條件變量或條件隊(duì)列），而在synchronized中，鎖對(duì)象的wait（）和notify（）或notifyAll（）方法可以實(shí)現(xiàn)一個(gè)隱含條件，但如果要和多于一個(gè)的條件關(guān)聯(lián)的時(shí)候，就不得不額外地添加一個(gè)鎖，而ReentrantLock則無(wú)需這么做，只需要多次調(diào)用newCondition（）方法即可。而且我們還可以通過(guò)綁定Condition對(duì)象來(lái)判斷當(dāng)前線程通知的是哪些線程（即與Condition對(duì)象綁定在一起的其他線程）。

可中斷鎖

    ReetrantLock有兩種鎖：忽略中斷鎖和響應(yīng)中斷鎖。忽略中斷鎖與synchronized實(shí)現(xiàn)的互斥鎖一樣，不能響應(yīng)中斷，而響應(yīng)中斷鎖可以響應(yīng)中斷。

    如果某一線程A正在執(zhí)行鎖中的代碼，另一線程B正在等待獲取該鎖，可能由于等待時(shí)間過(guò)長(zhǎng)，線程B不想等待了，想先處理其他事情，我們可以讓它中斷自己或者在別的線程中中斷它，如果此時(shí)ReetrantLock提供的是忽略中斷鎖，則它不會(huì)去理會(huì)該中斷，而是讓線程B繼續(xù)等待，而如果此時(shí)ReetrantLock提供的是響應(yīng)中斷鎖，那么它便會(huì)處理中斷，讓線程B放棄等待，轉(zhuǎn)而去處理其他事情。

  獲得響應(yīng)中斷鎖的一般形式如下：

	ReentrantLock lock = new ReentrantLock();
	...........
	lock.lockInterruptibly();//獲取響應(yīng)中斷鎖
	try {
	  //更新對(duì)象的狀態(tài)
	  //捕獲異常，必要時(shí)恢復(fù)到原來(lái)的不變約束
	  //如果有return語(yǔ)句，放在這里
	}finally{
		lock.unlock();  //鎖必須在finally塊中釋放
	}

    這里有一個(gè)不錯(cuò)的分析中斷的示例代碼（摘自網(wǎng)上）

    當(dāng)用synchronized中斷對(duì)互斥鎖的等待時(shí)，并不起作用，該線程依然會(huì)一直等待，如下面的實(shí)例：

public class Buffer {
 
 private Object lock;
 
 public Buffer() {
  lock = this;
 }
 
 public void write() {
  synchronized (lock) {
   long startTime = System.currentTimeMillis();
   System.out.println("開(kāi)始往這個(gè)buff寫(xiě)入數(shù)據(jù)…");
   for (;;)// 模擬要處理很長(zhǎng)時(shí)間 
   {
    if (System.currentTimeMillis()
      - startTime > Integer.MAX_VALUE) {
     break;
    }
   }
   System.out.println("終于寫(xiě)完了");
  }
 }
 
 public void read() {
  synchronized (lock) {
   System.out.println("從這個(gè)buff讀數(shù)據(jù)");
  }
 }
 
 public static void main(String[] args) {
  Buffer buff = new Buffer();
 
  final Writer writer = new Writer(buff);
  final Reader reader = new Reader(buff);
 
  writer.start();
  reader.start();
 
  new Thread(new Runnable() {
 
   @Override
   public void run() {
    long start = System.currentTimeMillis();
    for (;;) {
     //等5秒鐘去中斷讀 
     if (System.currentTimeMillis()
       - start > 5000) {
      System.out.println("不等了，嘗試中斷");
      reader.interrupt(); //嘗試中斷讀線程
      break;
     }
 
    }
 
   }
  }).start();
  // 我們期待“讀”這個(gè)線程能退出等待鎖，可是事與愿違，一旦讀這個(gè)線程發(fā)現(xiàn)自己得不到鎖，
  // 就一直開(kāi)始等待了，就算它等死，也得不到鎖，因?yàn)閷?xiě)線程要21億秒才能完成 T_T ，即使我們中斷它，
  // 它都不來(lái)響應(yīng)下，看來(lái)真的要等死了。這個(gè)時(shí)候，ReentrantLock給了一種機(jī)制讓我們來(lái)響應(yīng)中斷，
  // 讓“讀”能伸能屈，勇敢放棄對(duì)這個(gè)鎖的等待。我們來(lái)改寫(xiě)B(tài)uffer這個(gè)類(lèi)，就叫BufferInterruptibly吧，可中斷緩存。
 }
}
 
class Writer extends Thread {
 
 private Buffer buff;
 
 public Writer(Buffer buff) {
  this.buff = buff;
 }
 
 @Override
 public void run() {
  buff.write();
 }
}
 
class Reader extends Thread {
 
 private Buffer buff;
 
 public Reader(Buffer buff) {
  this.buff = buff;
 }
 
 @Override
 public void run() {
 
  buff.read();//這里估計(jì)會(huì)一直阻塞 
 
  System.out.println("讀結(jié)束");
 
 }
}

    執(zhí)行結(jié)果如下：

 我們等待了很久，后面依然沒(méi)有輸出，說(shuō)明讀線程對(duì)互斥鎖的等待并沒(méi)有被中斷，也就是該戶(hù)吃鎖沒(méi)有響應(yīng)對(duì)讀線程的中斷。    我們?cè)賹⑸厦娲a中synchronized的互斥鎖改為ReentrantLock的響應(yīng)中斷鎖，即改為如下代碼： 

import java.util.concurrent.locks.ReentrantLock;
 
public class BufferInterruptibly {
 
 private ReentrantLock lock = new ReentrantLock();
 
 public void write() {
  lock.lock();
  try {
   long startTime = System.currentTimeMillis();
   System.out.println("開(kāi)始往這個(gè)buff寫(xiě)入數(shù)據(jù)…");
   for (;;)// 模擬要處理很長(zhǎng)時(shí)間 
   {
    if (System.currentTimeMillis()
      - startTime > Integer.MAX_VALUE) {
     break;
    }
   }
   System.out.println("終于寫(xiě)完了");
  } finally {
   lock.unlock();
  }
 }
 
 public void read() throws InterruptedException {
  lock.lockInterruptibly();// 注意這里，可以響應(yīng)中斷 
  try {
   System.out.println("從這個(gè)buff讀數(shù)據(jù)");
  } finally {
   lock.unlock();
  }
 }
 
 public static void main(String args[]) {
  BufferInterruptibly buff = new BufferInterruptibly();
 
  final Writer2 writer = new Writer2(buff);
  final Reader2 reader = new Reader2(buff);
 
  writer.start();
  reader.start();
 
  new Thread(new Runnable() {
 
   @Override
   public void run() {
    long start = System.currentTimeMillis();
    for (;;) {
     if (System.currentTimeMillis()
       - start > 5000) {
      System.out.println("不等了，嘗試中斷");
      reader.interrupt(); //此處中斷讀操作
      break;
     }
    }
   }
  }).start();
 
 }
}
 
class Reader2 extends Thread {
 
 private BufferInterruptibly buff;
 
 public Reader2(BufferInterruptibly buff) {
  this.buff = buff;
 }
 
 @Override
 public void run() {
 
  try {
   buff.read();//可以收到中斷的異常，從而有效退出 
  } catch (InterruptedException e) {
   System.out.println("我不讀了");
  }
 
  System.out.println("讀結(jié)束");
 
 }
}
 
class Writer2 extends Thread {
 
 private BufferInterruptibly buff;
 
 public Writer2(BufferInterruptibly buff) {
  this.buff = buff;
 }
 
 @Override
 public void run() {
  buff.write();
 }
 
}

   執(zhí)行結(jié)果如下：

 從結(jié)果中可以看出，嘗試中斷后輸出了catch語(yǔ)句塊中的內(nèi)容，也輸出了后面的“讀結(jié)束”，說(shuō)明線程對(duì)互斥鎖的等待被中斷了，也就是該互斥鎖響應(yīng)了對(duì)讀線程的中斷。
條件變量實(shí)現(xiàn)線程間協(xié)作
    在生產(chǎn)者——消費(fèi)者模型一文中，我們用synchronized實(shí)現(xiàn)互斥，并配合使用Object對(duì)象的wait（）和notify（）或notifyAll（）方法來(lái)實(shí)現(xiàn)線程間協(xié)作。Java 5之后，我們可以用Reentrantlock鎖配合Condition對(duì)象上的await（）和signal（）或signalAll（）方法來(lái)實(shí)現(xiàn)線程間協(xié)作。在ReentrantLock對(duì)象上newCondition（）可以得到一個(gè)Condition對(duì)象，可以通過(guò)在Condition上調(diào)用await（）方法來(lái)掛起一個(gè)任務(wù)（線程），通過(guò)在Condition上調(diào)用signal（）來(lái)通知任務(wù)，從而喚醒一個(gè)任務(wù)，或者調(diào)用signalAll（）來(lái)喚醒所有在這個(gè)Condition上被其自身掛起的任務(wù)。另外，如果使用了公平鎖，signalAll（）的與Condition關(guān)聯(lián)的所有任務(wù)將以FIFO隊(duì)列的形式獲取鎖，如果沒(méi)有使用公平鎖，則獲取鎖的任務(wù)是隨機(jī)的，這樣我們便可以更好地控制處在await狀態(tài)的任務(wù)獲取鎖的順序。與notifyAll（）相比，signalAll（）是更安全的方式。另外，它可以指定喚醒與自身Condition對(duì)象綁定在一起的任務(wù)。
    下面將生產(chǎn)者——消費(fèi)者模型一文中的代碼改為用條件變量實(shí)現(xiàn)，如下：

import java.util.concurrent.*;
import java.util.concurrent.locks.*;
 
class Info{	// 定義信息類(lèi)
	private String name = "name";//定義name屬性，為了與下面set的name屬性區(qū)別開(kāi)
	private String content = "content" ;// 定義content屬性，為了與下面set的content屬性區(qū)別開(kāi)
	private boolean flag = true ;	// 設(shè)置標(biāo)志位,初始時(shí)先生產(chǎn)
	private Lock lock = new ReentrantLock(); 
	private Condition condition = lock.newCondition(); //產(chǎn)生一個(gè)Condition對(duì)象
	public void set(String name,String content){
		lock.lock();
		try{
			while(!flag){
				condition.await() ;
			}
			this.setName(name) ;	// 設(shè)置名稱(chēng)
			Thread.sleep(300) ;
			this.setContent(content) ;	// 設(shè)置內(nèi)容
			flag = false ;	// 改變標(biāo)志位，表示可以取走
			condition.signal();
		}catch(InterruptedException e){
			e.printStackTrace() ;
		}finally{
			lock.unlock();
		}
	}
 
	public void get(){
		lock.lock();
		try{
			while(flag){
				condition.await() ;
			}	
			Thread.sleep(300) ;
			System.out.println(this.getName() + 
				" --> " + this.getContent()) ;
			flag = true ;	// 改變標(biāo)志位，表示可以生產(chǎn)
			condition.signal();
		}catch(InterruptedException e){
			e.printStackTrace() ;
		}finally{
			lock.unlock();
		}
	}
 
	public void setName(String name){
		this.name = name ;
	}
	public void setContent(String content){
		this.content = content ;
	}
	public String getName(){
		return this.name ;
	}
	public String getContent(){
		return this.content ;
	}
}
class Producer implements Runnable{	// 通過(guò)Runnable實(shí)現(xiàn)多線程
	private Info info = null ;		// 保存Info引用
	public Producer(Info info){
		this.info = info ;
	}
	public void run(){
		boolean flag = true ;	// 定義標(biāo)記位
		for(int i=0;i<10;i++){
			if(flag){
				this.info.set("姓名--1","內(nèi)容--1") ;	// 設(shè)置名稱(chēng)
				flag = false ;
			}else{
				this.info.set("姓名--2","內(nèi)容--2") ;	// 設(shè)置名稱(chēng)
				flag = true ;
			}
		}
	}
}
class Consumer implements Runnable{
	private Info info = null ;
	public Consumer(Info info){
		this.info = info ;
	}
	public void run(){
		for(int i=0;i<10;i++){
			this.info.get() ;
		}
	}
}
public class ThreadCaseDemo{
	public static void main(String args[]){
		Info info = new Info();	// 實(shí)例化Info對(duì)象
		Producer pro = new Producer(info) ;	// 生產(chǎn)者
		Consumer con = new Consumer(info) ;	// 消費(fèi)者
		new Thread(pro).start() ;
		//啟動(dòng)了生產(chǎn)者線程后，再啟動(dòng)消費(fèi)者線程
		try{
			Thread.sleep(500) ;
		}catch(InterruptedException e){
			e.printStackTrace() ;
		}
 
		new Thread(con).start() ;
	}
}

    執(zhí)行后，同樣可以得到如下的結(jié)果：

姓名--1 --> 內(nèi)容--1
姓名--2 --> 內(nèi)容--2
姓名--1 --> 內(nèi)容--1
姓名--2 --> 內(nèi)容--2
姓名--1 --> 內(nèi)容--1
姓名--2 --> 內(nèi)容--2
姓名--1 --> 內(nèi)容--1
姓名--2 --> 內(nèi)容--2
姓名--1 --> 內(nèi)容--1
姓名--2 --> 內(nèi)容--2

    從以上并不能看出用條件變量的await（）、signal（）、signalAll（）方法比用Object對(duì)象的wait（）、notify（）、notifyAll（）方法實(shí)現(xiàn)線程間協(xié)作有多少優(yōu)點(diǎn)，但它在處理更復(fù)雜的多線程問(wèn)題時(shí)，會(huì)有明顯的優(yōu)勢(shì)。所以，Lock和Condition對(duì)象只有在更加困難的多線程問(wèn)題中才是必須的。  

讀寫(xiě)鎖

    另外，synchronized獲取的互斥鎖不僅互斥讀寫(xiě)操作、寫(xiě)寫(xiě)操作，還互斥讀讀操作，而讀讀操作時(shí)不會(huì)帶來(lái)數(shù)據(jù)競(jìng)爭(zhēng)的，因此對(duì)對(duì)讀讀操作也互斥的話，會(huì)降低性能。Java 5中提供了讀寫(xiě)鎖，它將讀鎖和寫(xiě)鎖分離，使得讀讀操作不互斥，獲取讀鎖和寫(xiě)鎖的一般形式如下：

ReadWriteLock rwl = new ReentrantReadWriteLock();	 
rwl.writeLock().lock() //獲取寫(xiě)鎖
rwl.readLock().lock() //獲取讀鎖

   用讀鎖來(lái)鎖定讀操作，用寫(xiě)鎖來(lái)鎖定寫(xiě)操作，這樣寫(xiě)操作和寫(xiě)操作之間會(huì)互斥，讀操作和寫(xiě)操作之間會(huì)互斥，但讀操作和讀操作就不會(huì)互斥。

   《Java并發(fā)編程實(shí)踐》一書(shū)給出了使用 ReentrantLock的最佳時(shí)機(jī)：

    當(dāng)你需要以下高級(jí)特性時(shí)，才應(yīng)該使用：可定時(shí)的、可輪詢(xún)的與可中斷的鎖獲取操作，公平隊(duì)列，或者非塊結(jié)構(gòu)的鎖。否則，請(qǐng)使用synchronized。     

到此這篇關(guān)于淺談Java并發(fā)編程之Lock鎖和條件變量的文章就介紹到這了,更多相關(guān)Java并發(fā)編程之Lock鎖和條件變量?jī)?nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論