Jdk1.5 以后，在 java.util.concurrent.locks 包下，有一組實現(xiàn)線程同步的接口和類，說到線程的同步，可能大家都會想到 synchronized 關鍵字，

這是 java 內(nèi)置的關鍵字，用來處理線程同步的，但這個關鍵字有很多的缺陷，使用起來也不是很方便和直觀，所以就出現(xiàn)了 Lock，下面，我們

就來對比著講解 Lock。

通常我們在使用 synchronized 關鍵字的時候會遇到下面這些問題：

（1）不可控性，無法做到隨心的加鎖和釋放鎖。

（2）效率比較低下，比如我們現(xiàn)在并發(fā)的讀兩個文件，讀與讀之間是互不影響的，但如果給這個讀的對象使用 synchronized 來實現(xiàn)同步的話，

那么只要有一個線程進入了，那么其他的線程都要等待。

（3）無法知道線程是否獲取到了鎖。

而上面 synchronized 的這些問題，Lock 都可以很好的解決，并且 jdk1.5 以后，還提供了各種鎖，例如讀寫鎖，但有一點需要注意，使用 synchronized

關鍵時，無須手動釋放鎖，但使用 Lock 必須手動釋放鎖。下面我們就來學習一下 Lock 鎖。

Lock 是一個上層的接口，其原型如下，總共提供了 6 個方法：

public interface Lock {
　　// 用來獲取鎖，如果鎖已經(jīng)被其他線程獲取，則一直等待，直到獲取到鎖
   void lock();
　　// 該方法獲取鎖時，可以響應中斷，比如現(xiàn)在有兩個線程，一個已經(jīng)獲取到了鎖，另一個線程調(diào)用這個方法正在等待鎖，但是此刻又不想讓這個線程一直在這死等，可以通過
　　　　調(diào)用線程的Thread.interrupted()方法，來中斷線程的等待過程
　　void lockInterruptibly() throws InterruptedException;
　　// tryLock方法會返回bool值，該方法會嘗試著獲取鎖，如果獲取到鎖，就返回true，如果沒有獲取到鎖，就返回false，但是該方法會立刻返回，而不會一直等待
   boolean tryLock();
　　// 這個方法和上面的tryLock差不多是一樣的，只是會嘗試指定的時間，如果在指定的時間內(nèi)拿到了鎖，則會返回true，如果在指定的時間內(nèi)沒有拿到鎖，則會返回false
   boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
　　// 釋放鎖
   void unlock();
　　// 實現(xiàn)線程通信，相當于wait和notify，后面會單獨講解
   Condition newCondition();
}

那么這幾個方法該如何使用了？前面我們說到，使用 Lock 是需要手動釋放鎖的，但是如果程序中拋出了異常，那么就無法做到釋放鎖，有可能引起死鎖，

所以我們在使用 Lock 的時候，有一種固定的格式，如下：

Lock l = ...;
      l.lock();
      try {
      　　// access the resource protected by this lock
      } finally {// 必須使用try，最后在finally里面釋放鎖
      　　l.unlock();
      }

下面我們來看一個簡單的例子，代碼如下：

/**
 * 描述：Lock使用
 */
public class LockDemo {
    // new一個鎖對象，注意此處必須聲明成類對象，保持只有一把鎖,ReentrantLock是Lock的唯一實現(xiàn)類
   Lock lock = new ReentrantLock();
   public void readFile(String fileMessage){
      lock.lock();// 上鎖
      try{
         System.out.println(Thread.currentThread().getName()+"得到了鎖，正在讀取文件……");
         for(int i=0; i<fileMessage.length(); i++){
            System.out.print(fileMessage.charAt(i));
         }
         System.out.println();
         System.out.println("文件讀取完畢！");
      }finally{
         System.out.println(Thread.currentThread().getName()+"釋放了鎖！");
         lock.unlock();
      }
   }
   public void demo(final String fileMessage){
      // 創(chuàng)建若干個線程
      ExecutorService service = Executors.newCachedThreadPool();
      // 提交20個任務
      for(int i=0; i<20; i++){
         service.execute(new Runnable() {
            @Override
            public void run() {
               readFile(fileMessage);
               try {
                  Thread.sleep(20);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
            }
         });
      }
    // 釋放線程池中的線程
      service.shutdown();
   }
}

Lock與synchronized的對比

1、作用

lock 和 synchronized 都是 Java 中去用來解決線程安全問題的一個工具。

2、來源

sychronized 是 Java 中的一個關鍵字。

lock 是 JUC 包里面提供的一個接口，這個接口有很多實現(xiàn)類，其中就包括我們最常用的 ReentrantLock(可重入鎖)。

3、鎖的力度

sychronized 可以通過兩種方式去控制鎖的力度：

把 sychronized 關鍵字修飾在方法層面。
修飾在代碼塊上。
鎖對象的不同：

鎖對象為靜態(tài)對象或者是class對象，那這個鎖屬于全局鎖。
鎖對象為普通實例對象，那這個鎖的范圍取決于這個實例的生命周期。
lock鎖的力度是通過 lock()與unlock()兩個方法決定的。在兩個方法之間的代碼能保證其線程安全。lock的作用域取決于lock實例的生命周期。

4、靈活性

lock鎖比sychronized的靈活性更高。

lock可以自主的去決定什么時候加鎖與釋放鎖。只需要調(diào)用lock 的lock()和unlock()這兩個方法就可以。

sychronized 由于是一個關鍵字，所以他無法實現(xiàn)非阻塞競爭鎖的方法，一個線程獲取鎖之后，其他鎖只能等待那個線程釋放之后才能有獲取鎖的機會。

5、公平鎖與非公平鎖

公平鎖：多個線程按照申請鎖的順序去獲得鎖，線程會直接進入隊列去排隊，永遠都是隊列的第一位才能得到鎖。

優(yōu)點：所有的線程都能得到資源，不會餓死。
缺點：吞吐量低，隊列里面除了第一個線程，其他的線程都會阻塞，cpu喚醒阻塞線程的開銷大。
非公平鎖：多個線程去獲取鎖的時候，會直接去嘗試獲取，獲取不到，再去進入等待隊列，如果能獲取到，就直接獲取到鎖。

優(yōu)點：可以減少CPU喚醒線程的開銷，整體的吞吐效率會高點，CPU也不必取喚醒所有線程，會減少喚起線程的數(shù)量。
缺點：可能導致隊列中間的線程一直獲取不到鎖或者長時間獲取不到鎖，最終餓死。
lock提供了公平鎖和非公平鎖兩種機制（默認非公平鎖）。

sychronized是非公平鎖。

6、異常是否釋放鎖

synchronized鎖的釋放是被動的，當sychronized同步代碼塊執(zhí)行結束或者出現(xiàn)異常的時候才會被釋放。

lock鎖發(fā)生異常的時候，不會主動釋放占有的鎖，必須手動unlock()來釋放，所以我們一般都是將同步代碼塊放進try-catch里面，finally中寫入unlock()方法，避免死鎖發(fā)生。

7、判斷是否能獲取鎖

synchronized不能。

lock提供了非阻塞競爭鎖的方法trylock()，返回值是Boolean類型。它表示的是用來嘗試獲取鎖：成功獲取則返回true；獲取失敗則返回false，這個方法無論如何都會立即返回。

8、調(diào)度方式

synchronized使用的是object對象本身的wait、notify、notifyAll方法，而lock使用的是Condition進行線程之間的調(diào)度。

9、是否能中斷

synchronized只能等待鎖的釋放，不能響應中斷。

lock等待鎖過程中可以用interrupt()來中斷。

10、性能

如果競爭不激烈，性能差不多；競爭激烈時，lock的性能會更好。

lock鎖還能使用readwritelock實現(xiàn)讀寫分離，提高多線程的讀操作效率。

11、sychronized鎖升級

synchronized 代碼塊是由一對 monitorenter/monitorexit 指令實現(xiàn)的。Monitor的實現(xiàn)完全是依靠操作系統(tǒng)內(nèi)部的互斥鎖，因為需要進行用戶態(tài)到內(nèi)核態(tài)的切換，所以同步操作是一個無差別的重量級操作。

所以現(xiàn)在JVM提供了三種不同的鎖：偏向鎖、輕量級鎖、重量級鎖。

偏向鎖：
當沒有競爭出現(xiàn)時，默認使用偏向鎖。線程會利用 CAS 操作在對象頭上設置線程 ID ，以表示對象偏向當前線程。

目的：在很多應用場景中，大部分對象生命周期最多會被一個線程鎖定，使用偏向鎖可以降低無競爭時的開銷。

輕量級鎖：
JVM比較當前線程的 threadID 和 Java 對象頭中的threadID是否一致，如果不一致（比如線程2要競爭鎖對象），那么需要查看 Java 對象頭中記錄的線程1是否存活（偏向鎖不會主動釋放因此還是存儲的線程1的 threadID），如果沒有存活，那么鎖對象還是為偏向鎖（對象頭中的threadID為線程2的）；如果存活，那么撤銷偏向鎖，升級為輕量級鎖。

當有其他線程想訪問加了輕量級鎖的資源時，會使用自旋鎖優(yōu)化，來進行資源訪問。

目的：競爭鎖對象的線程不多，而且線程持有鎖的時間也不長的情景。因為阻塞線程需要CPU從用戶態(tài)轉到內(nèi)核態(tài)，開銷大，如果剛剛阻塞不久這個鎖就被釋放了，就得不償失了，因此這個時候就干脆不阻塞這個線程，讓它自旋這等待鎖釋放。

重量級鎖：
自旋失敗，很大概率 再一次自選也是失敗，因此直接升級成重量級鎖，進行線程阻塞，減少cpu消耗。

當鎖升級為重量級鎖后，未搶到鎖的線程都會被阻塞，進入阻塞隊列。

到此這篇關于Java多線程中Lock的使用小結的文章就介紹到這了,更多相關Java多線程Lock內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論