Java多線程-鎖的區別與使用

目錄

• 鎖類型
  • 可中斷鎖
  • 公平鎖/非公平鎖
  • 可重入鎖
  • 獨享鎖/共享鎖
  • 互斥鎖/讀寫鎖
  • 樂觀鎖/悲觀鎖
  • 分段鎖
  • 偏向鎖/輕量級鎖/重量級鎖
  • 自旋鎖
• Synchronized與Static Synchronized
  • 舉例
• Lock
  • 定義
  • 四種獲取Lock的方法區別
    • lock()
    • tryLock()
    • tryLock(long time, TimeUnit unit)
    • lockInterruptibly()
• synchronized與Lock的區別

鎖類型

可中斷鎖

• 在等待獲取鎖過程當中可中斷
• Lock就是可中斷鎖

公平鎖/非公平鎖

• 公平鎖是指多個線程按照申請鎖的順序來獲取鎖。
• 非公平鎖是指多個線程獲取鎖的順序並非按照申請鎖的順序，有可能後申請的線程比先申請的線程優先獲取鎖。有可能，會形成優先級反轉或者飢餓現象。
• 對於ReentrantLock而言，經過構造函數指定該鎖是不是公平鎖，默認是非公平鎖。非公平鎖的優勢在於吞吐量比公平鎖大。
• 對於Synchronized而言，也是一種非公平鎖。因爲其並不像ReentrantLock是經過AQS的來實現線程調度，因此並無任何辦法使其變成公平鎖。

可重入鎖

• 可重入鎖又名遞歸鎖，是指在同一個線程在外層方法獲取鎖的時候，在進入內層方法會自動獲取鎖。
• 對於Java ReentrantLock而言, 他的名字就能夠看出是一個可重入鎖，其名字是Re entrant Lock從新進入鎖。
• 對於Synchronized而言,也是一個可重入鎖。可重入鎖的一個好處是可必定程度避免死鎖。

synchronized void setA() throws Exception{
 
    Thread.sleep(1000);
 
    setB();
 
}
 
synchronized void setB() throws Exception{
 
    Thread.sleep(1000);
 
}

獨享鎖/共享鎖

• 獨享鎖是指該鎖一次只能被一個線程所持有。
• 共享鎖是指該鎖可被多個線程所持有。
• 對於Java ReentrantLock而言，其是獨享鎖。可是對於Lock的另外一個實現類ReadWriteLock，其讀鎖是共享鎖，其寫鎖是獨享鎖。
• 讀鎖的共享鎖可保證併發讀是很是高效的，讀寫，寫讀 ，寫寫的過程是互斥的。
• 獨享鎖與共享鎖也是經過AQS來實現的，經過實現不一樣的方法，來實現獨享或者共享。
• Synchronized是獨享鎖。

互斥鎖/讀寫鎖

• 上面講的獨享鎖/共享鎖就是一種廣義的說法，互斥鎖/讀寫鎖就是具體的實現。
• 互斥鎖在Java中的具體實現就是ReentrantLock
• 讀寫鎖在Java中的具體實現就是ReadWriteLock

樂觀鎖/悲觀鎖

• 樂觀鎖與悲觀鎖不是指具體的什麼類型的鎖，而是指看待併發同步的角度。
• 悲觀鎖認爲對於同一個數據的併發操做，必定是會發生修改的，哪怕沒有修改，也會認爲修改。所以對於同一個數據的併發操做，悲觀鎖採起加鎖的形式。悲觀的認爲，不加鎖的併發操做必定會出問題。
• 樂觀鎖則認爲對於同一個數據的併發操做，是不會發生修改的。在更新數據的時候，會採用嘗試更新，不斷從新的方式更新數據。樂觀的認爲，不加鎖的併發操做是沒有事情的。
• 從上面的描述咱們能夠看出，悲觀鎖適合寫操做很是多的場景，樂觀鎖適合讀操做很是多的場景，不加鎖會帶來大量的性能提高。
• 悲觀鎖在Java中的使用，就是利用各類鎖。
• 樂觀鎖在Java中的使用，是無鎖編程，經常採用的是CAS算法，典型的例子就是原子類，經過CAS自旋實現原子操做的更新。

分段鎖

• 分段鎖實際上是一種鎖的設計，並非具體的一種鎖，對於ConcurrentHashMap而言，其併發的實現就是經過分段鎖的形式來實現高效的併發操做。
• 分段鎖的設計目的是細化鎖的粒度，當操做不須要更新整個數組的時候，就僅僅針對數組中的一項進行加鎖操做。

偏向鎖/輕量級鎖/重量級鎖

• 這三種鎖是指鎖的狀態，而且是針對Synchronized。在Java 5經過引入鎖升級的機制來實現高效Synchronized。這三種鎖的狀態是經過對象監視器在對象頭中的字段來代表的。
• 偏向鎖是指一段同步代碼一直被一個線程所訪問，那麼該線程會自動獲取鎖。下降獲取鎖的代價。
• 輕量級鎖是指當鎖是偏向鎖的時候，被另外一個線程所訪問，偏向鎖就會升級爲輕量級鎖，其餘線程會經過自旋的形式嘗試獲取鎖，不會阻塞，提升性能。
• 重量級鎖是指當鎖爲輕量級鎖的時候，另外一個線程雖然是自旋，但自旋不會一直持續下去，當自旋必定次數的時候，尚未獲取到鎖，就會進入阻塞，該鎖膨脹爲重量級鎖。重量級鎖會讓其餘申請的線程進入阻塞，性能下降。

自旋鎖

• 自旋鎖原理很是簡單，若是持有鎖的線程能在很短期內釋放鎖資源，那麼那些等待競爭鎖的線程就不須要作內核態和用戶態之間的切換進入阻塞掛起狀態，它們只須要等一等（自旋），等持有鎖的線程釋放鎖後便可當即獲取鎖，這樣就避免用戶線程和內核的切換的消耗。
• 可是線程自旋是須要消耗cup的，說白了就是讓cup在作無用功，若是一直獲取不到鎖，那線程也不能一直佔用cup自旋作無用功，因此須要設定一個自旋等待的最大時間。
• 若是持有鎖的線程執行的時間超過自旋等待的最大時間扔沒有釋放鎖，就會致使其它爭用鎖的線程在最大等待時間內仍是獲取不到鎖，這時爭用線程會中止自旋進入阻塞狀態。

Synchronized與Static Synchronized

區別

• static synchronized方法是類鎖，synchronized方法是對象鎖

• synchronized至關於 this.synchronized，static synchronized至關於Something.synchronized

舉例

pulbic class Test(){
    public synchronized void A(){}
    public synchronized void B(){}
    public static synchronized void cA(){}
    public static synchronized void cB(){}
}

新建兩個實例，x和y

1 x.A()與x.B() 
2 x.A()與y.A()
3 x.cA()與y.cB()
4 x.A()與Test.cA()

四種狀況哪組方法何以被多個以上線程同時訪問？

• 狀況1：同一個實例上鎖確定不行
• 狀況2：是針對不一樣實例的，所以能夠同時被訪問
• 狀況3：由於static synchronized爲類鎖，因此不一樣實例之間仍然會被限制
• 狀況4：能夠，類鎖和實例鎖互不干擾

Lock

定義

Lock是一個接口

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

• lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用來獲取鎖的。
• unLock()方法是用來釋放鎖的。

四種獲取Lock的方法區別

lock()

日常使用得最多的一個方法，就是用來獲取鎖。若是鎖已被其餘線程獲取，則進行等待。

使用Lock必須在try{}catch{}塊中進行，而且將釋放鎖的操做放在finally塊中進行，以保證鎖必定被被釋放，防止死鎖的發生。

Lock lock = ...;
lock.lock();
try{
    //處理任務
}catch(Exception ex){
     
}finally{
    lock.unlock();   //釋放鎖
}

tryLock()

tryLock()有返回值的，它表示用來嘗試獲取鎖，若是獲取成功，則返回true，若是鎖已被其餘線程獲取，則返回false。

這個方法會當即返回，在拿不到鎖時也不會一直在那等待。

Lock lock = ...;
if(lock.tryLock()) {
     try{
         //處理任務
     }catch(Exception ex){
         
     }finally{
         lock.unlock();   //釋放鎖
     } 
}else {
    //若是不能獲取鎖，則直接作其餘事情
}

tryLock(long time, TimeUnit unit)

此方法在拿不到鎖時會等待必定的時間，在時間期限以內若是還拿不到鎖，就返回false。若是若是一開始拿到鎖或者在等待期間內拿到了鎖，則返回true。

lockInterruptibly()方法比較特殊，當經過這個方法去獲取鎖時，若是線程正在等待獲取鎖，則這個線程可以響應中斷，即中斷線程的等待狀態。也就使說，當兩個線程同時經過lock.lockInterruptibly()想獲取某個鎖時，倘若此時線程A獲取到了鎖，而線程B還在等待，那麼對線程B調用threadB.interrupt()方法中斷線程B的等待過程。

lockInterruptibly()

當經過lockInterruptibly()方法獲取某個鎖時，若是不能獲取到，只有進行等待的狀況下，是能夠響應中斷的。

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

當一個線程獲取了鎖以後，是不會被interrupt()方法中斷的。單獨調用interrupt()方法不能中斷正在運行過程當中的線程，只能中斷阻塞過程當中的線程。

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

public void method() throws InterruptedException {
    lock.lockInterruptibly();
    try {  
     //.....
    }
    finally {
        lock.unlock();
    }  
}

synchronized與Lock的區別