Java多線程中Lock怎么使用

這篇文章主要介紹了Java多線程中Lock怎么使用的相關知識，內容詳細易懂，操作簡單快捷，具有一定借鑒價值，相信大家閱讀完這篇Java多線程中Lock怎么使用文章都會有所收獲，下面我們一起來看看吧。

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

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

就來對比著講解 Lock。

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

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

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

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

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

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

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

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

public interface Lock {
　　// 用來獲取鎖，如果鎖已經被其他線程獲取，則一直等待，直到獲取到鎖
   void lock();
　　// 該方法獲取鎖時，可以響應中斷，比如現在有兩個線程，一個已經獲取到了鎖，另一個線程調用這個方法正在等待鎖，但是此刻又不想讓這個線程一直在這死等，可以通過
　　　　調用線程的Thread.interrupted()方法，來中斷線程的等待過程
　　void lockInterruptibly() throws InterruptedException;
　　// tryLock方法會返回bool值，該方法會嘗試著獲取鎖，如果獲取到鎖，就返回true，如果沒有獲取到鎖，就返回false，但是該方法會立刻返回，而不會一直等待
   boolean tryLock();
　　// 這個方法和上面的tryLock差不多是一樣的，只是會嘗試指定的時間，如果在指定的時間內拿到了鎖，則會返回true，如果在指定的時間內沒有拿到鎖，則會返回false
   boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
　　// 釋放鎖
   void unlock();
　　// 實現線程通信，相當于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的唯一實現類
   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){
      // 創建若干個線程
      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 包里面提供的一個接口，這個接口有很多實現類，其中就包括我們最常用的 ReentrantLock(可重入鎖)。

3、鎖的力度

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

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

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

4、靈活性

lock鎖比sychronized的靈活性更高。

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

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

5、公平鎖與非公平鎖

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

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

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

sychronized是非公平鎖。

6、異常是否釋放鎖

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

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

7、判斷是否能獲取鎖

synchronized不能。

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

8、調度方式

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

9、是否能中斷

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

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

10、性能

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

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

11、sychronized鎖升級

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

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

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

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

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

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

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

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

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

關于“Java多線程中Lock怎么使用”這篇文章的內容就介紹到這里，感謝各位的閱讀！相信大家對“Java多線程中Lock怎么使用”知識都有一定的了解，大家如果還想學習更多知識，歡迎關注億速云行業資訊頻道。