碼上歡樂
相關內容    簡體    繁體

synchronized與Lock的區別與使用

本文轉載自   查看原文   2018-09-22 16:01   2305    sychronized/ java面試題/ 深入理解java並發/ Lock
版權聲明：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/u012403290/article/details/64910926

引言：

昨天在學習別人分享的面試經驗時，看到Lock的使用。想起自己在上次面試也遇到了synchronized與Lock的區別與使用。於是，我整理了兩者的區別和使用情況，同時，對synchronized的使用過程一些常見問題的總結，最后是參照源碼和說明文檔，對Lock的使用寫了幾個簡單的Demo。請大家批評指正。

技術點：

1、線程與進程：

在開始之前先把進程與線程進行區分一下，一個程序最少需要一個進程，而一個進程最少需要一個線程。關系是線程–>進程–>程序的大致組成結構。所以線程是程序執行流的最小單位，而進程是系統進行資源分配和調度的一個獨立單位。以下我們所有討論的都是建立在線程基礎之上。

2、Thread的幾個重要方法：

我們先了解一下Thread的幾個重要方法。a、start()方法，調用該方法開始執行該線程；b、stop()方法，調用該方法強制結束該線程執行；c、join方法，調用該方法等待該線程結束。d、sleep()方法，調用該方法該線程進入等待。e、run()方法，調用該方法直接執行線程的run()方法，但是線程調用start()方法時也會運行run()方法，區別就是一個是由線程調度運行run()方法，一個是直接調用了線程中的run()方法！！

看到這里，可能有些人就會問啦，那wait()和notify()呢？要注意，其實wait()與notify()方法是Object的方法，不是Thread的方法！！同時，wait()與notify()會配合使用，分別表示線程掛起和線程恢復。

這里還有一個很常見的問題，順帶提一下：wait()與sleep()的區別，簡單來說wait()會釋放對象鎖而sleep()不會釋放對象鎖。這些問題有很多的資料，不再贅述。

3、線程狀態：

這里寫圖片描述

線程總共有5大狀態，通過上面第二個知識點的介紹，理解起來就簡單了。

  • 新建狀態：新建線程對象，並沒有調用start()方法之前

  • 就緒狀態：調用start()方法之后線程就進入就緒狀態，但是並不是說只要調用start()方法線程就馬上變為當前線程，在變為當前線程之前都是為就緒狀態。值得一提的是，線程在睡眠和掛起中恢復的時候也會進入就緒狀態哦。

  • 運行狀態：線程被設置為當前線程，開始執行run()方法。就是線程進入運行狀態

  • 阻塞狀態：線程被暫停，比如說調用sleep()方法后線程就進入阻塞狀態

  • 死亡狀態：線程執行結束

4、鎖類型

  • 可重入鎖：在執行對象中所有同步方法不用再次獲得鎖

  • 可中斷鎖：在等待獲取鎖過程中可中斷

  • 公平鎖： 按等待獲取鎖的線程的等待時間進行獲取，等待時間長的具有優先獲取鎖權利

  • 讀寫鎖：對資源讀取和寫入的時候拆分為2部分處理，讀的時候可以多線程一起讀，寫的時候必須同步地寫

synchronized與Lock的區別

1、我把兩者的區別分類到了一個表中，方便大家對比：

類別 synchronized Lock
存在層次 Java的關鍵字，在jvm層面上 是一個類
鎖的釋放 1、以獲取鎖的線程執行完同步代碼，釋放鎖 2、線程執行發生異常，jvm會讓線程釋放鎖 在finally中必須釋放鎖，不然容易造成線程死鎖
鎖的獲取 假設A線程獲得鎖，B線程等待。如果A線程阻塞，B線程會一直等待 分情況而定，Lock有多個鎖獲取的方式，具體下面會說道，大致就是可以嘗試獲得鎖，線程可以不用一直等待
鎖狀態 無法判斷 可以判斷
鎖類型 可重入 不可中斷 非公平 可重入 可判斷 可公平（兩者皆可）
性能 少量同步 大量同步

或許，看到這里還對LOCK所知甚少，那么接下來，我們進入LOCK的深入學習。

Lock詳細介紹與Demo

以下是Lock接口的源碼，筆者修剪之后的結果：

public interface Lock {

    /** * Acquires the lock. */
    void lock();

    /** * Acquires the lock unless the current thread is * {@linkplain Thread#interrupt interrupted}. */
    void lockInterruptibly() throws InterruptedException;

    /** * Acquires the lock only if it is free at the time of invocation. */
    boolean tryLock();

    /** * Acquires the lock if it is free within the given waiting time and the * current thread has not been {@linkplain Thread#interrupt interrupted}. */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /** * Releases the lock. */
    void unlock();

}
從Lock接口中我們可以看到主要有個方法，這些方法的功能從注釋中可以看出：
  • 1

  • lock()：獲取鎖，如果鎖被暫用則一直等待

  • unlock():釋放鎖

  • tryLock(): 注意返回類型是boolean，如果獲取鎖的時候鎖被占用就返回false，否則返回true

  • tryLock(long time, TimeUnit unit)：比起tryLock()就是給了一個時間期限，保證等待參數時間

  • lockInterruptibly()：用該鎖的獲得方式，如果線程在獲取鎖的階段進入了等待，那么可以中斷此線程，先去做別的事

通過 以上的解釋，大致可以解釋在上個部分中“鎖類型(lockInterruptibly())”，“鎖狀態(tryLock())”等問題，還有就是前面子所獲取的過程我所寫的“大致就是可以嘗試獲得鎖，線程可以不會一直等待”用了“可以”的原因。

下面是Lock一般使用的例子，注意ReentrantLock是Lock接口的實現。
  • 1

lock()：


package com.brickworkers;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
    private Lock lock = new ReentrantLock();

    //需要參與同步的方法
    private void method(Thread thread){
        lock.lock();
        try {
            System.out.println("線程名"+thread.getName() + "獲得了鎖");
        }catch(Exception e){
            e.printStackTrace();
        } finally {
            System.out.println("線程名"+thread.getName() + "釋放了鎖");
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();

        //線程1
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method(Thread.currentThread());
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method(Thread.currentThread());
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}
//執行情況：線程名t1獲得了鎖
// 線程名t1釋放了鎖
// 線程名t2獲得了鎖
// 線程名t2釋放了鎖

tryLock():

package com.brickworkers;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
    private Lock lock = new ReentrantLock();

    //需要參與同步的方法
    private void method(Thread thread){
/* lock.lock(); try { System.out.println("線程名"+thread.getName() + "獲得了鎖"); }catch(Exception e){ e.printStackTrace(); } finally { System.out.println("線程名"+thread.getName() + "釋放了鎖"); lock.unlock(); }*/


        if(lock.tryLock()){
            try {
                System.out.println("線程名"+thread.getName() + "獲得了鎖");
            }catch(Exception e){
                e.printStackTrace();
            } finally {
                System.out.println("線程名"+thread.getName() + "釋放了鎖");
                lock.unlock();
            }
        }else{
            System.out.println("我是"+Thread.currentThread().getName()+"有人占着鎖，我就不要啦");
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();

        //線程1
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method(Thread.currentThread());
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                lockTest.method(Thread.currentThread());
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

//執行結果： 線程名t2獲得了鎖
// 我是t1有人占着鎖，我就不要啦
// 線程名t2釋放了鎖

看到這里相信大家也都會使用如何使用Lock了吧，關於tryLock(long time, TimeUnit unit)和lockInterruptibly()不再贅述。前者主要存在一個等待時間，在測試代碼中寫入一個等待時間，后者主要是等待中斷，會拋出一個中斷異常，常用度不高，喜歡探究可以自己深入研究。

前面比較重提到“公平鎖”，在這里可以提一下ReentrantLock對於平衡鎖的定義，在源碼中有這么兩段：

 


 /** * Sync object for non-fair locks */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /** * Performs lock. Try immediate barge, backing up to normal * acquire on failure. */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

    /** * Sync object for fair locks */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

        /** * Fair version of tryAcquire. Don't grant access unless * recursive call or no waiters or is first. */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

從以上源碼可以看出在Lock中可以自己控制鎖是否公平，而且，默認的是非公平鎖，以下是ReentrantLock的構造函數：

   public ReentrantLock() {
        sync = new NonfairSync();//默認非公平鎖
    }
 
 2018/10/1更新

今天看了並發實踐這本書的ReentantLock這章，感覺對ReentantLock還是不夠熟悉，有許多疑問，所有在網上找了很多文章看了一下，總體說的不夠詳細，重點和焦點問題沒有談到，但這篇文章相當不錯，說的很全面，主要的重點都說到了，所有在這里轉載了這篇文章，注意紅色字體。

　　在上一篇文章中我們講到了如何使用關鍵字synchronized來實現同步訪問。本文我們繼續來探討這個問題，從Java 5之后，在java.util.concurrent.locks包下提供了另外一種方式來實現同步訪問，那就是Lock。

　　也許有朋友會問，既然都可以通過synchronized來實現同步訪問了，那么為什么還需要提供Lock？這個問題將在下面進行闡述。本文先從synchronized的缺陷講起，然后再講述java.util.concurrent.locks包下常用的有哪些類和接口，最后討論以下一些關於鎖的概念方面的東西

　　以下是本文目錄大綱：

　　一.synchronized的缺陷

　　二.java.util.concurrent.locks包下常用的類

　　三.鎖的相關概念介紹

　　若有不正之處請多多諒解，並歡迎批評指正。

　　請尊重作者勞動成果，轉載請標明原文鏈接：

 　　http://www.cnblogs.com/dolphin0520/p/3923167.html

一.synchronized的缺陷

　　synchronized是java中的一個關鍵字，也就是說是Java語言內置的特性。那么為什么會出現Lock呢？

　　在上面一篇文章中，我們了解到如果一個代碼塊被synchronized修飾了，當一個線程獲取了對應的鎖，並執行該代碼塊時，其他線程便只能一直等待，等待獲取鎖的線程釋放鎖，而這里獲取鎖的線程釋放鎖只會有兩種情況：

　　1）獲取鎖的線程執行完了該代碼塊，然后線程釋放對鎖的占有；

　　2）線程執行發生異常，此時JVM會讓線程自動釋放鎖。

　　那么如果這個獲取鎖的線程由於要等待IO或者其他原因（比如調用sleep方法）被阻塞了，但是又沒有釋放鎖，其他線程便只能干巴巴地等待，試想一下，這多么影響程序執行效率。

　　因此就需要有一種機制可以不讓等待的線程一直無期限地等待下去（比如只等待一定的時間或者能夠響應中斷），通過Lock就可以辦到。

　　再舉個例子：當有多個線程讀寫文件時，讀操作和寫操作會發生沖突現象，寫操作和寫操作會發生沖突現象，但是讀操作和讀操作不會發生沖突現象。

　　但是采用synchronized關鍵字來實現同步的話，就會導致一個問題：

　　如果多個線程都只是進行讀操作，所以當一個線程在進行讀操作時，其他線程只能等待無法進行讀操作。

　　因此就需要一種機制來使得多個線程都只是進行讀操作時，線程之間不會發生沖突，通過Lock就可以辦到。

　　另外，通過Lock可以知道線程有沒有成功獲取到鎖。這個是synchronized無法辦到的。

　　總結一下，也就是說Lock提供了比synchronized更多的功能。但是要注意以下幾點：

　　1）Lock不是Java語言內置的，synchronized是Java語言的關鍵字，因此是內置特性。Lock是一個類，通過這個類可以實現同步訪問；

　　2）Lock和synchronized有一點非常大的不同，采用synchronized不需要用戶去手動釋放鎖，當synchronized方法或者synchronized代碼塊執行完之后，系統會自動讓線程釋放對鎖的占用；而Lock則必須要用戶去手動釋放鎖，如果沒有主動釋放鎖，就有可能導致出現死鎖現象。

二.java.util.concurrent.locks包下常用的類

　　下面我們就來探討一下java.util.concurrent.locks包中常用的類和接口。

　　1.Lock

　　首先要說明的就是Lock，通過查看Lock的源碼可知，Lock是一個接口：

1
2
3
4
5
6
7
8
public  interface  Lock {
     void  lock();
     void  lockInterruptibly()  throws  InterruptedException;
     boolean  tryLock();
     boolean  tryLock( long  time, TimeUnit unit)  throws  InterruptedException;
     void  unlock();
     Condition newCondition();
}

 　　下面來逐個講述Lock接口中每個方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用來獲取鎖的。unLock()方法是用來釋放鎖的。newCondition()這個方法暫且不在此講述，會在后面的線程協作一文中講述。

　　在Lock中聲明了四個方法來獲取鎖，那么這四個方法有何區別呢？

　　首先lock()方法是平常使用得最多的一個方法，就是用來獲取鎖。如果鎖已被其他線程獲取，則進行等待。

　　由於在前面講到如果采用Lock，必須主動去釋放鎖，並且在發生異常時，不會自動釋放鎖。因此一般來說，使用Lock必須在try{}catch{}塊中進行，並且將釋放鎖的操作放在finally塊中進行，以保證鎖一定被被釋放，防止死鎖的發生。通常使用Lock來進行同步的話，是以下面這種形式去使用的：

1
2
3
4
5
6
7
8
9
Lock lock = ...;
lock.lock();
try {
     //處理任務
} catch (Exception ex){
     
} finally {
     lock.unlock();    //釋放鎖
}

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

　　tryLock(long time, TimeUnit unit)方法和tryLock()方法是類似的，只不過區別在於這個方法在拿不到鎖時會等待一定的時間，在時間期限之內如果還拿不到鎖，就返回false。如果如果一開始拿到鎖或者在等待期間內拿到了鎖，則返回true。

　　所以，一般情況下通過tryLock來獲取鎖時是這樣使用的：

1
2
3
4
5
6
7
8
9
10
11
12
Lock lock = ...;
if (lock.tryLock()) {
      try {
          //處理任務
      } catch (Exception ex){
         
      } finally {
          lock.unlock();    //釋放鎖
      } 
} else  {
     //如果不能獲取鎖，則直接做其他事情
}

 　　lockInterruptibly()方法比較特殊，當通過這個方法去獲取鎖時，如果線程正在等待獲取鎖，則這個線程能夠響應中斷，即中斷線程的等待狀態。也就使說，當兩個線程同時通過lock.lockInterruptibly()想獲取某個鎖時，假若此時線程A獲取到了鎖，而線程B只有在等待，那么對線程B調用threadB.interrupt()方法能夠中斷線程B的等待過程。

　　由於lockInterruptibly()的聲明中拋出了異常，所以lock.lockInterruptibly()必須放在try塊中或者在調用lockInterruptibly()的方法外聲明拋出InterruptedException。

　　因此lockInterruptibly()一般的使用形式如下：

1
2
3
4
5
6
7
8
9
public  void  method()  throws  InterruptedException {
     lock.lockInterruptibly();
     try  {  
      //.....
     }
     finally  {
         lock.unlock();
     }  
}

　　注意，當一個線程獲取了鎖之后，是不會被interrupt()方法中斷的。因為本身在前面的文章中講過單獨調用interrupt()方法不能中斷正在運行過程中的線程，只能中斷阻塞過程中的線程。

　　因此當通過lockInterruptibly()方法獲取某個鎖時，如果不能獲取到，只有進行等待的情況下，是可以響應中斷的。

　　而用synchronized修飾的話，當一個線程處於等待某個鎖的狀態，是無法被中斷的，只有一直等待下去。

　　2.ReentrantLock

　　ReentrantLock，意思是“可重入鎖”，關於可重入鎖的概念在下一節講述。ReentrantLock是唯一實現了Lock接口的類，並且ReentrantLock提供了更多的方法。下面通過一些實例看具體看一下如何使用ReentrantLock。

　　例子1，lock()的正確使用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public  class  Test {
     private  ArrayList<Integer> arrayList =  new  ArrayList<Integer>();
     public  static  void  main(String[] args)  {
         final  Test test =  new  Test();
         
         new  Thread(){
             public  void  run() {
                 test.insert(Thread.currentThread());
             };
         }.start();
         
         new  Thread(){
             public  void  run() {
                 test.insert(Thread.currentThread());
             };
         }.start();
     }  
     
     public  void  insert(Thread thread) {
         Lock lock =  new  ReentrantLock();     //注意這個地方
         lock.lock();
         try  {
             System.out.println(thread.getName()+ "得到了鎖" );
             for ( int  i= 0 ;i< 5 ;i++) {
                 arrayList.add(i);
             }
         }  catch  (Exception e) {
             // TODO: handle exception
         } finally  {
             System.out.println(thread.getName()+ "釋放了鎖" );
             lock.unlock();
         }
     }
}

 　　各位朋友先想一下這段代碼的輸出結果是什么？

Thread-0得到了鎖
Thread-1得到了鎖
Thread-0釋放了鎖
Thread-1釋放了鎖

　　也許有朋友會問，怎么會輸出這個結果？第二個線程怎么會在第一個線程釋放鎖之前得到了鎖？原因在於，在insert方法中的lock變量是局部變量，每個線程執行該方法時都會保存一個副本，那么理所當然每個線程執行到lock.lock()處獲取的是不同的鎖，所以就不會發生沖突。

　　知道了原因改起來就比較容易了，只需要將lock聲明為類的屬性即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public  class  Test {
     private  ArrayList<Integer> arrayList =  new  ArrayList<Integer>();
     private  Lock lock =  new  ReentrantLock();     //注意這個地方
     public  static  void  main(String[] args)  {
         final  Test test =  new  Test();
         
         new  Thread(){
             public  void  run() {
                 test.insert(Thread.currentThread());
             };
         }.start();
         
         new  Thread(){
             public  void  run() {
                 test.insert(Thread.currentThread());
             };
         }.start();
     }  
     
     public  void  insert(Thread thread) {
         lock.lock();
         try  {
             System.out.println(thread.getName()+ "得到了鎖" );
             for ( int  i= 0 ;i< 5 ;i++) {
                 arrayList.add(i);
             }
         }  catch  (Exception e) {
             // TODO: handle exception
         } finally  {
             System.out.println(thread.getName()+ "釋放了鎖" );
             lock.unlock();
         }
     }
}

 　　這樣就是正確地使用Lock的方法了。

　　例子2，tryLock()的使用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public  class  Test {
     private  ArrayList<Integer> arrayList =  new  ArrayList<Integer>();
     private  Lock lock =  new  ReentrantLock();     //注意這個地方
     public  static  void  main(String[] args)  {
         final  Test test =  new  Test();
         
         new  Thread(){
             public  void  run() {
                 test.insert(Thread.currentThread());
             };
         }.start();
         
         new  Thread(){
             public  void  run() {
                 test.insert(Thread.currentThread());
             };
         }.start();
     }  
     
     public  void  insert(Thread thread) {
         if (lock.tryLock()) {
             try  {
                 System.out.println(thread.getName()+ "得到了鎖" );
                 for ( int  i= 0 ;i< 5 ;i++) {
                     arrayList.add(i);
                 }
             }  catch  (Exception e) {
                 // TODO: handle exception
             } finally  {
                 System.out.println(thread.getName()+ "釋放了鎖" );
                 lock.unlock();
             }
         }  else  {
             System.out.println(thread.getName()+ "獲取鎖失敗" );
         }
     }
}

 　　輸出結果：

Thread-0得到了鎖
Thread-1獲取鎖失敗
Thread-0釋放了鎖

　　例子3，lockInterruptibly()響應中斷的使用方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public  class  Test {
     private  Lock lock =  new  ReentrantLock();   
     public  static  void  main(String[] args)  {
         Test test =  new  Test();
         MyThread thread1 =  new  MyThread(test);
         MyThread thread2 =  new  MyThread(test);
         thread1.start();
         thread2.start();
         
         try  {
             Thread.sleep( 2000 );
         }  catch  (InterruptedException e) {
             e.printStackTrace();
         }
         thread2.interrupt();
     }  
     
     public  void  insert(Thread thread)  throws  InterruptedException{
         lock.lockInterruptibly();    //注意，如果需要正確中斷等待鎖的線程，必須將獲取鎖放在外面，然后將InterruptedException拋出
         try  {  
             System.out.println(thread.getName()+ "得到了鎖" );
             long  startTime = System.currentTimeMillis();
             for (    ;     ;) {
                 if (System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
                     break ;
                 //插入數據
             }
         }
         finally  {
             System.out.println(Thread.currentThread().getName()+ "執行finally" );
             lock.unlock();
             System.out.println(thread.getName()+ "釋放了鎖" );
         }  
     }
}
 
class  MyThread  extends  Thread {
     private  Test test =  null ;
     public  MyThread(Test test) {
         this .test = test;
     }
     @Override
     public  void  run() {
         
         try  {
             test.insert(Thread.currentThread());
         }  catch  (InterruptedException e) {
             System.out.println(Thread.currentThread().getName()+ "被中斷" );
         }
     }
}

　　運行之后，發現thread2能夠被正確中斷。

　　3.ReadWriteLock

　　ReadWriteLock也是一個接口，在它里面只定義了兩個方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public  interface  ReadWriteLock {
     /**
      * Returns the lock used for reading.
      *
      * @return the lock used for reading.
      */
     Lock readLock();
 
     /**
      * Returns the lock used for writing.
      *
      * @return the lock used for writing.
      */
     Lock writeLock();
}

 　　一個用來獲取讀鎖，一個用來獲取寫鎖。也就是說將文件的讀寫操作分開，分成2個鎖來分配給線程，從而使得多個線程可以同時進行讀操作。下面的ReentrantReadWriteLock實現了ReadWriteLock接口。

　　4.ReentrantReadWriteLock

　　ReentrantReadWriteLock里面提供了很多豐富的方法，不過最主要的有兩個方法：readLock()和writeLock()用來獲取讀鎖和寫鎖。

　　下面通過幾個例子來看一下ReentrantReadWriteLock具體用法。

　　假如有多個線程要同時進行讀操作的話，先看一下synchronized達到的效果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public  class  Test {
     private  ReentrantReadWriteLock rwl =  new  ReentrantReadWriteLock();
     
     public  static  void  main(String[] args)  {
         final  Test test =  new  Test();
         
         new  Thread(){
             public  void  run() {
                 test.get(Thread.currentThread());
             };
         }.start();
         
         new  Thread(){
             public  void  run() {
                 test.get(Thread.currentThread());
             };
         }.start();
         
     }  
     
     public  synchronized  void  get(Thread thread) {
         long  start = System.currentTimeMillis();
         while (System.currentTimeMillis() - start <=  1 ) {
             System.out.println(thread.getName()+ "正在進行讀操作" );
         }
         System.out.println(thread.getName()+ "讀操作完畢" );
     }
}

 　　這段程序的輸出結果會是，直到thread1執行完讀操作之后，才會打印thread2執行讀操作的信息。

復制代碼 
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0讀操作完畢
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1讀操作完畢
復制代碼

　　而改成用讀寫鎖的話：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public  class  Test {
     private  ReentrantReadWriteLock rwl =  new  ReentrantReadWriteLock();
     
     public  static  void  main(String[] args)  {
         final  Test test =  new  Test();
         
         new  Thread(){
             public  void  run() {
                 test.get(Thread.currentThread());
             };
         }.start();
         
         new  Thread(){
             public  void  run() {
                 test.get(Thread.currentThread());
             };
         }.start();
         
     }  
     
     public  void  get(Thread thread) {
         rwl.readLock().lock();
         try  {
             long  start = System.currentTimeMillis();
             
             while (System.currentTimeMillis() - start <=  1 ) {
                 System.out.println(thread.getName()+ "正在進行讀操作" );
             }
             System.out.println(thread.getName()+ "讀操作完畢" );
         }  finally  {
             rwl.readLock().unlock();
         }
     }
}

 　　此時打印的結果為：

復制代碼 
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0正在進行讀操作
Thread-1正在進行讀操作
Thread-0讀操作完畢
Thread-1讀操作完畢
復制代碼

　　說明thread1和thread2在同時進行讀操作。

　　這樣就大大提升了讀操作的效率。

　　不過要注意的是，如果有一個線程已經占用了讀鎖，則此時其他線程如果要申請寫鎖，則申請寫鎖的線程會一直等待釋放讀鎖。

　　如果有一個線程已經占用了寫鎖，則此時其他線程如果申請寫鎖或者讀鎖，則申請的線程會一直等待釋放寫鎖。

　　關於ReentrantReadWriteLock類中的其他方法感興趣的朋友可以自行查閱API文檔。

　　5.Lock和synchronized的選擇

　　總結來說，Lock和synchronized有以下幾點不同：

　　1）Lock是一個接口，而synchronized是Java中的關鍵字，synchronized是內置的語言實現；

　　2）synchronized在發生異常時，會自動釋放線程占有的鎖，因此不會導致死鎖現象發生；而Lock在發生異常時，如果沒有主動通過unLock()去釋放鎖，則很可能造成死鎖現象，因此使用Lock時需要在finally塊中釋放鎖；

　　3）Lock可以讓等待鎖的線程響應中斷，而synchronized卻不行，使用synchronized時，等待的線程會一直等待下去，不能夠響應中斷；

　　4）通過Lock可以知道有沒有成功獲取鎖，而synchronized卻無法辦到。

　　5）Lock可以提高多個線程進行讀操作的效率。

　　在性能上來說，如果競爭資源不激烈，兩者的性能是差不多的，而當競爭資源非常激烈時（即有大量線程同時競爭），此時Lock的性能要遠遠優於synchronized。所以說，在具體使用時要根據適當情況選擇。

三.鎖的相關概念介紹

　　在前面介紹了Lock的基本使用，這一節來介紹一下與鎖相關的幾個概念。

　　1.可重入鎖

　　如果鎖具備可重入性，則稱作為可重入鎖。像synchronized和ReentrantLock都是可重入鎖，可重入性在我看來實際上表明了鎖的分配機制：基於線程的分配，而不是基於方法調用的分配。舉個簡單的例子，當一個線程執行到某個synchronized方法時，比如說method1，而在method1中會調用另外一個synchronized方法method2，此時線程不必重新去申請鎖，而是可以直接執行方法method2。

　　看下面這段代碼就明白了：

1
2
3
4
5
6
7
8
9
class  MyClass {
     public  synchronized  void  method1() {
         method2();
     }
     
     public  synchronized  void  method2() {
         
     }
}

 　　上述代碼中的兩個方法method1和method2都用synchronized修飾了，假如某一時刻，線程A執行到了method1，此時線程A獲取了這個對象的鎖，而由於method2也是synchronized方法，假如synchronized不具備可重入性，此時線程A需要重新申請鎖。但是這就會造成一個問題，因為線程A已經持有了該對象的鎖，而又在申請獲取該對象的鎖，這樣就會線程A一直等待永遠不會獲取到的鎖。

　　而由於synchronized和Lock都具備可重入性，所以不會發生上述現象。

　　2.可中斷鎖

　　可中斷鎖：顧名思義，就是可以相應中斷的鎖。

　　在Java中，synchronized就不是可中斷鎖，而Lock是可中斷鎖。

　　如果某一線程A正在執行鎖中的代碼，另一線程B正在等待獲取該鎖，可能由於等待時間過長，線程B不想等待了，想先處理其他事情，我們可以讓它中斷自己或者在別的線程中中斷它，這種就是可中斷鎖。

　　在前面演示lockInterruptibly()的用法時已經體現了Lock的可中斷性。

　　3.公平鎖

　　公平鎖即盡量以請求鎖的順序來獲取鎖。比如同是有多個線程在等待一個鎖，當這個鎖被釋放時，等待時間最久的線程（最先請求的線程）會獲得該所，這種就是公平鎖。

　　非公平鎖即無法保證鎖的獲取是按照請求鎖的順序進行的。這樣就可能導致某個或者一些線程永遠獲取不到鎖。

　　在Java中，synchronized就是非公平鎖，它無法保證等待的線程獲取鎖的順序。

　　而對於ReentrantLock和ReentrantReadWriteLock，它默認情況下是非公平鎖，但是可以設置為公平鎖。

　　看一下這2個類的源代碼就清楚了：

　　

　　在ReentrantLock中定義了2個靜態內部類，一個是NotFairSync，一個是FairSync，分別用來實現非公平鎖和公平鎖。

　　我們可以在創建ReentrantLock對象時，通過以下方式來設置鎖的公平性：

1
ReentrantLock lock =  new  ReentrantLock( true );

 　　如果參數為true表示為公平鎖，為fasle為非公平鎖。默認情況下，如果使用無參構造器，則是非公平鎖。

　　

　　另外在ReentrantLock類中定義了很多方法，比如：

　　isFair()        //判斷鎖是否是公平鎖

　　isLocked()    //判斷鎖是否被任何線程獲取了

　　isHeldByCurrentThread()   //判斷鎖是否被當前線程獲取了

　　hasQueuedThreads()   //判斷是否有線程在等待該鎖

　　在ReentrantReadWriteLock中也有類似的方法，同樣也可以設置為公平鎖和非公平鎖。不過要記住，ReentrantReadWriteLock並未實現Lock接口，它實現的是ReadWriteLock接口。

　　4.讀寫鎖

　　讀寫鎖將對一個資源（比如文件）的訪問分成了2個鎖，一個讀鎖和一個寫鎖。

　　正因為有了讀寫鎖，才使得多個線程之間的讀操作不會發生沖突。

　　ReadWriteLock就是讀寫鎖，它是一個接口，ReentrantReadWriteLock實現了這個接口。

　　可以通過readLock()獲取讀鎖，通過writeLock()獲取寫鎖。

　　上面已經演示過了讀寫鎖的使用方法，在此不再贅述。

尾記錄：

筆者水平一般，不過此博客在引言中的目的已全部達到。這只是筆者在學習過程中的總結與概括，如存在不正確的，歡迎大家批評指出。

延伸學習：對於LOCK底層的實現，大家可以參考：
點擊Lock底層介紹博客

兩種同步方式性能測試，大家可以參考：
點擊查看兩種同步方式性能測試博客

博主18年3月新增：

回來看自己博客。發現東西闡述的不夠完整。這里在做補充，因為這篇博客訪問較大，所以為了不誤導大家，盡量介紹給大家正確的表述：
1、兩種鎖的底層實現方式：
synchronized：我們知道java是用字節碼指令來控制程序（這里不包括熱點代碼編譯成機器碼）。在字節指令中，存在有synchronized所包含的代碼塊，那么會形成2段流程的執行。

我們點擊查看SyncDemo.java的源碼SyncDemo.class，可以看到如下：
這里寫圖片描述

如上就是這段代碼段字節碼指令，沒你想的那么難吧。言歸正傳，我們可以清晰段看到，其實synchronized映射成字節碼指令就是增加來兩個指令：monitorenter和monitorexit。當一條線程進行執行的遇到monitorenter指令的時候，它會去嘗試獲得鎖，如果獲得鎖那么鎖計數+1（為什么會加一呢，因為它是一個可重入鎖，所以需要用這個鎖計數判斷鎖的情況），如果沒有獲得鎖，那么阻塞。當它遇到monitorexit的時候，鎖計數器-1，當計數器為0，那么就釋放鎖。

那么有的朋友看到這里就疑惑了，那圖上有2個monitorexit呀？馬上回答這個問題：上面我以前寫的文章也有表述過，synchronized鎖釋放有兩種機制，一種就是執行完釋放；另外一種就是發送異常，虛擬機釋放。圖中第二個monitorexit就是發生異常時執行的流程，這就是我開頭說的“會有2個流程存在“。而且，從圖中我們也可以看到在第13行，有一個goto指令，也就是說如果正常運行結束會跳轉到19行執行。

這下，你對synchronized是不是了解的很清晰了呢。接下來我們再聊一聊Lock。

Lock：Lock實現和synchronized不一樣，后者是一種悲觀鎖，它膽子很小，它很怕有人和它搶吃的，所以它每次吃東西前都把自己關起來。而Lock呢底層其實是CAS樂觀鎖的體現，它無所謂，別人搶了它吃的，它重新去拿吃的就好啦，所以它很樂觀。具體底層怎么實現，博主不在細述，有機會的話，我會對concurrent包下面的機制好好和大家說說，如果面試問起，你就說底層主要靠volatile和CAS操作實現的。

現在，才是我真正想在這篇博文后面加的，我要說的是：盡可能去使用synchronized而不要去使用LOCK

什么概念呢？我和大家打個比方：你叫jdk，你生了一個孩子叫synchronized，后來呢，你領養了一個孩子叫LOCK。起初，LOCK剛來到新家的時候，它很乖，很懂事，各個方面都表現的比synchronized好。你很開心，但是你內心深處又有一點淡淡的憂傷，你不希望你自己親生的孩子竟然還不如一個領養的孩子乖巧。這個時候，你對親生的孩子教育更加深刻了，你想證明，你的親生孩子synchronized並不會比領養的孩子LOCK差。（博主只是打個比方）

那如何教育呢？
在jdk1.6~jdk1.7的時候，也就是synchronized16、7歲的時候，你作為爸爸，你給他優化了，具體優化在哪里呢：

1、線程自旋和適應性自旋
我們知道，java’線程其實是映射在內核之上的，線程的掛起和恢復會極大的影響開銷。並且jdk官方人員發現，很多線程在等待鎖的時候，在很短的一段時間就獲得了鎖，所以它們在線程等待的時候，並不需要把線程掛起，而是讓他無目的的循環，一般設置10次。這樣就避免了線程切換的開銷，極大的提升了性能。
而適應性自旋，是賦予了自旋一種學習能力，它並不固定自旋10次一下。他可以根據它前面線程的自旋情況，從而調整它的自旋，甚至是不經過自旋而直接掛起。

2、鎖消除
什么叫鎖消除呢？就是把不必要的同步在編譯階段進行移除。
那么有的小伙伴又迷糊了，我自己寫的代碼我會不知道這里要不要加鎖？我加了鎖就是表示這邊會有同步呀？
並不是這樣，這里所說的鎖消除並不一定指代是你寫的代碼的鎖消除，我打一個比方：
在jdk1.5以前，我們的String字符串拼接操作其實底層是StringBuffer來實現的（這個大家可以用我前面介紹的方法，寫一個簡單的demo，然后查看class文件中的字節碼指令就清楚了），而在jdk1.5之后，那么是用StringBuilder來拼接的。我們考慮前面的情況，比如如下代碼：

String str1="qwe";
String str2="asd";
String str3=str1+str2;

底層實現會變成這樣：

StringBuffer sb = new StringBuffer();
sb.append("qwe");
sb.append("asd");

我們知道，StringBuffer是一個線程安全的類，也就是說兩個append方法都會同步，通過指針逃逸分析（就是變量不會外泄），我們發現在這段代碼並不存在線程安全問題，這個時候就會把這個同步鎖消除。

3、鎖粗化
在用synchronized的時候，我們都講究為了避免大開銷，盡量同步代碼塊要小。那么為什么還要加粗呢？
我們繼續以上面的字符串拼接為例，我們知道在這一段代碼中，每一個append都需要同步一次，那么我可以把鎖粗化到第一個append和最后一個append（這里不要去糾結前面的鎖消除，我只是打個比方）

4、輕量級鎖

5、偏向鎖

關於最后這兩種，我希望留個有緣的讀者自己去查找，我不希望我把一件事情描述的那么詳細，自己動手得到才是你自己的，博主可以告訴你的是，最后兩種並不難。。加油吧，各位。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Lock和synchronized的區別和使用 synchronized和lock的區別和使用 synchronized和lock以及synchronized和volatile的區別 synchronized和Lock的區別 synchronized和lock有什么區別？ lock與synchronized的區別 Synchronized 和 ReentrantLock （Lock ）的區別 Lock與synchronized 的區別 synchronized與Lock的區別 synchronized和Lock有什么區別？
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM