java 線程中經常遇到的鎖的講解

時間 2020-01-11

標籤 java 線程經常遇到講解欄目 Java 简体版

原文原文鏈接

怎樣產生死鎖

互斥條件：指進程對所分配到的資源進行排它性使用，即在一段時間內某資源只由一個進程佔用。若是此時還有其它進程請求該資源，則請求者只能等待，直至佔有該資源的進程用畢釋放。
請求和保持條件：指進程已經保持了至少一個資源，但又提出了新的資源請求，而該資源又被其它進程佔有，此時請求進程阻塞，但又對本身得到的其它資源保持不放。
不剝奪條件：指進程已得到資源，在使用完以前，不能被剝奪，只能在使用完時由本身釋放。
環路等待條件：指在發生死鎖時，必然存在一個進程—資源的環形鏈，即進程集合（P0，P1,P2,…,Pn）中的P0正在等待一個P1佔用的資源；P1正在等待一個P2佔用的資源，……,Pn正在等待已被P0佔用的資源。

如何避免死鎖

加鎖順序
加鎖時限
死鎖檢測

public class T2 {
    public String str="abc";

    static class R1 implements Runnable{
        public String str;
        public Object o1;
        public Object o2;

        public R1(String str,Object ob1,Object ob2) {
            this.str=str;
            this.o1=ob1;
            this.o2=ob2;
        }
        @Override
        public void run() {
            if (str.contains("a")){
                synchronized (o1){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (o2){
                        System.out.println("aaa-bbb");
                    }
                }
            }
            if (str.contains("b")){
              synchronized (o2){
                  try {
                      Thread.sleep(2000);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  synchronized (o1){
                      System.out.println("bbb-aaa");
                  }
              }
            }
        }
    }
    public static void main(String[] args){
        Object ob1=new Object();
        Object ob2=new Object();
        R1 r1=new R1("a",ob1,ob2);
        Thread thread1=new Thread(r1);
        thread1.start();

        R1 r2=new R1("b",ob1,ob2);
        Thread thread2=new Thread(r2);
        thread2.start();

    }


}
複製代碼

線程能提升程序的運行速度嗎？

多線程程序並不能提升程序的運行速度，但可以提升程序運行效率，讓CPU的使用率更高。html

1. 鎖的分類

公平鎖、非公平鎖
可重入鎖
獨享鎖/共享鎖
互斥鎖/讀寫鎖
樂觀鎖/悲觀鎖
分段鎖
偏向鎖/輕量級鎖/重量級鎖
自旋鎖

公平鎖/非公平鎖

公平鎖是指多個線程按照申請鎖的順序來獲取鎖。公平鎖不會產生飢餓鎖，也就是隻要排隊等待，最終能等待到獲取鎖的機會。使用重入鎖（默認是非公平鎖）建立公平鎖：
非公平鎖是指多個線程獲取鎖的順序並非按照申請鎖的順序，有可能後申請的線程比先申請的線程優先獲取鎖。有可能，會形成優先級反轉或者飢餓現象。
對於ReentrantLock而言，經過構造函數指定該鎖是不是公平鎖，默認是非公平鎖。非公平鎖的優勢在於吞吐量比公平鎖大。對於Synchronized而言，也是一種非公平鎖。因爲其並不像ReentrantLock是經過AQS的來實現線程調度，因此並無任何辦法使其變成公平鎖。

ReenTrantLock實例

使用重入鎖（默認是非公平鎖）建立公平鎖：java

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}
final ReentrantLock lock = new ReentrantLock();
final ReentrantLock lock = new ReentrantLock(false);
複製代碼

可重入鎖

可重入鎖又名遞歸鎖，是指在同一個線程在外層方法獲取鎖的時候，在進入內層方法會自動獲取鎖android

對於ReentrantLock而言, 他的名字就能夠看出是一個可重入鎖，其名字是Re entrant Lock從新進入鎖。
對於Synchronized而言,也是一個可重入鎖。可重入鎖的一個好處是可必定程度避免死鎖。

可重入鎖的實現要點

獲取鎖後，再次獲取該鎖時；判斷當前線程是不是已經獲取鎖的線程，如果，則經過；不然，阻塞。
釋放鎖時，若是該線程獲取了n(n>=1)次鎖，則須要釋放n次，才能釋放成功，返回true；不然，返回false。

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

synchronized void setB() throws Exception{
    Thread.sleep(1000);
}
複製代碼

上面的代碼就是一個可重入鎖的一個特色，若是不是可重入鎖的話，setB可能不會被當前線程執行，可能形成死鎖.面試

首先先看看ReentrantLock

1. 中斷響應

對於synchronized塊來講，要麼獲取到鎖執行，要麼持續等待。而重入鎖的中斷響應功能就合理地避免了這樣的狀況。好比，一個正在等待獲取鎖的線程被「告知」無須繼續等待下去，就能夠中止工做了。算法

2. 鎖申請等待限時

可使用 tryLock()或者tryLock(long timeout, TimeUtil unit) 方法進行一次限時的鎖等待。數據庫

前者不帶參數，這時線程嘗試獲取鎖，若是獲取到鎖則繼續執行，若是鎖被其餘線程持有，則當即返回 false ，也就是不會使當前線程等待，因此不會產生死鎖。
後者帶有參數，表示在指定時長內獲取到鎖則繼續執行，若是等待指定時長後尚未獲取到鎖則返回false。

public class TryLockTest implements Runnable{
    public static ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            if (lock.tryLock(1, TimeUnit.SECONDS)) { // 等待1秒
                Thread.sleep(2000);  //休眠2秒
            } else {
                System.err.println(Thread.currentThread().getName() + "獲取鎖失敗！");
            }
        } catch (Exception e) {
            if (lock.isHeldByCurrentThread()) lock.unlock();
        }

    }
    public static void main(String[] args) throws InterruptedException {
        TryLockTest test = new TryLockTest();
        Thread t1 = new Thread(test); t1.setName("線程1");
        Thread t2 = new Thread(test); t1.setName("線程2");
        t1.start();t2.start();
    }

}
複製代碼

獨享鎖()/共享鎖

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

互斥鎖/共享鎖（讀鎖）/排它鎖（寫鎖）

獨享鎖/共享鎖就是一種廣義的說法，互斥鎖/讀寫鎖就是具體的實現。編程

互斥鎖在Java中的具體實現就是ReentrantLock.
讀寫鎖在Java中的具體實現就是ReadWriteLock.
共享鎖（S鎖）：共享 (S) 用於不更改或不更新數據的操做（只讀操做），如 SELECT 語句。若是事務T對數據A加上共享鎖後，則其餘事務只能對A再加共享鎖，不能加排他鎖。獲准共享鎖的事務只能讀數據，不能修改數據。
排他鎖（X鎖）：用於數據修改操做，例如INSERT、UPDATE 或DELETE。確保不會同時同一資源進行多重更新。若是事務T對數據A加上排他鎖後，則其餘事務不能再對A加任任何類型的封鎖。獲准排他鎖的事務既能讀數據，又能修改數據。咱們在操做數據庫的時候，可能會因爲併發問題而引發的數據的不一致性（數據衝突）。

樂觀鎖/悲觀鎖

樂觀鎖與悲觀鎖不是指具體的什麼類型的鎖，而是指看待併發同步的角度。數組

悲觀鎖認爲對於同一個數據的併發操做，必定是會發生修改的，哪怕沒有修改，也會認爲修改。所以對於同一個數據的併發操做，悲觀鎖採起加鎖的形式。悲觀的認爲，不加鎖的併發操做必定會出問題。
樂觀鎖則認爲對於同一個數據的併發操做，是不會發生修改的。在更新數據的時候，會採用嘗試更新，不斷從新的方式更新數據。樂觀的認爲，不加鎖的併發操做是沒有事情的。
悲觀鎖在Java中的使用，就是利用各類鎖。樂觀鎖在Java中的使用，是無鎖編程，經常採用的是CAS算法，典型的例子就是原子類，經過CAS自旋實現原子操做的更新。

兩種鎖的使用場景

從上面對兩種鎖的介紹，咱們知道兩種鎖各有優缺點，不可認爲一種好於另外一種，==像樂觀鎖適用於寫比較少的狀況下（多讀場景）==，即衝突真的不多發生的時候，這樣能夠省去了鎖的開銷，加大了系統的整個吞吐量。但若是是多寫的狀況，通常會常常產生衝突，這就會致使上層應用會不斷的進行retry，這樣反卻是下降了性能，因此通常多寫的場景下用悲觀鎖就比較合適。多線程

樂觀鎖常見的兩種實現方式

1. 版本號機制

通常是在數據表中加上一個數據版本號version字段，表示數據被修改的次數，當數據被修改時，version值會加一。當線程A要更新數據值時，在讀取數據的同時也會讀取version值，在提交更新時，若剛纔讀取到的version值爲當前數據庫中的version值相等時才更新，不然重試更新操做，直到更新成功。併發

2.CAS算法

即compare and swap（比較與交換），是一種有名的無鎖算法。無鎖編程，即不使用鎖的狀況下實現多線程之間的變量同步，也就是在沒有線程被阻塞的狀況下實現變量的同步，因此也叫非阻塞同步（Non-blocking Synchronization）。CAS算法涉及到三個操做數。

須要讀寫的內存值 V
進行比較的值 A
擬寫入的新值 B

樂觀鎖的缺點

1. ABA問題

若是一個變量V初次讀取的時候是A值，而且在準備賦值的時候檢查到它仍然是A值，那咱們就能說明它的值沒有被其餘線程修改過了嗎？很明顯是不能的，由於在這段時間它的值可能被改成其餘值，而後又改回A，那CAS操做就會誤認爲它歷來沒有被修改過。這個問題被稱爲CAS操做的 "ABA"問題。

2.循環時間長開銷大

自旋CAS（也就是不成功就一直循環執行直到成功）若是長時間不成功，會給CPU帶來很是大的執行開銷。若是JVM能支持處理器提供的pause指令那麼效率會有必定的提高，pause指令有兩個做用，第一它能夠延遲流水線執行指令（de-pipeline）,使CPU不會消耗過多的執行資源，延遲的時間取決於具體實現的版本，在一些處理器上延遲時間是零。第二它能夠避免在退出循環的時候因內存順序衝突（memory order violation）而引發CPU流水線被清空（CPU pipeline flush），從而提升CPU的執行效率。

3 只能保證一個共享變量的原子操做

CAS 只對單個共享變量有效，當操做涉及跨多個共享變量時 CAS 無效。可是從 JDK 1.5開始，提供了 AtomicReference類來保證引用對象之間的原子性，你能夠把多個變量放在一個對象裏來進行 CAS 操做.因此咱們可使用鎖或者利用 AtomicReference類把多個共享變量合併成一個共享變量來操做。

分段鎖

分段鎖實際上是一種鎖的設計，並非具體的一種鎖，對於ConcurrentHashMap而言，其併發的實現就是經過分段鎖的形式來實現高效的併發操做.

咱們以ConcurrentHashMap來講一下分段鎖的含義以及設計思想，ConcurrentHashMap中的分段鎖稱爲Segment，它即相似於HashMap（JDK7與JDK8中HashMap的實現）的結構，即內部擁有一個Entry數組，數組中的每一個元素又是一個鏈表；同時又是一個ReentrantLock（Segment繼承了ReentrantLock)。
當須要put元素的時候，並非對整個hashmap進行加鎖，而是先經過hashcode來知道他要放在那一個分段中，而後對這個分段進行加鎖，因此當多線程put的時候，只要不是放在一個分段中，就實現了真正的並行的插入。
可是，在統計size的時候，可就是獲取hashmap全局信息的時候，就須要獲取全部的分段鎖才能統計。
分段鎖的設計目的是細化鎖的粒度，當操做不須要更新整個數組的時候，就僅僅針對數組中的一項進行加鎖操做。

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

這三種鎖是指鎖的狀態，而且是針對Synchronized。在Java 5經過引入鎖升級的機制來實現高效Synchronized。這三種鎖的狀態是經過對象監視器在對象頭中的字段來代表的。

偏向鎖是指一段同步代碼一直被一個線程所訪問，那麼該線程會自動獲取鎖。下降獲取鎖的代價。
輕量級鎖是指當鎖是偏向鎖的時候，被另外一個線程所訪問，偏向鎖就會升級爲輕量級鎖，其餘線程會經過自旋的形式嘗試獲取鎖，不會阻塞，提升性能。
重量級鎖是指當鎖爲輕量級鎖的時候，另外一個線程雖然是自旋，但自旋不會一直持續下去，當自旋必定次數的時候，尚未獲取到鎖，就會進入阻塞，該鎖膨脹爲重量級鎖。重量級鎖會讓其餘申請的線程進入阻塞，性能下降。

重量級鎖Synchronized

1. Synchronized的做用

做用於方法時，鎖住的是對象的實例(this)
看成用於靜態方法時，鎖住的是Class實例，又由於Class的相關數據存儲在永久帶PermGen（jdk1.8則是metaspace），永久帶是全局共享的，所以靜態方法鎖至關於類的一個全局鎖，會鎖全部調用該方法的線程.
synchronized做用於一個對象實例時，鎖住的是全部以該對象爲鎖的代碼塊.

2. Synchronized的實現

自旋鎖

在Java中，自旋鎖是指嘗試獲取鎖的線程不會當即阻塞，而是採用循環的方式去嘗試獲取鎖，這樣的好處是減小線程上下文切換的消耗，缺點是循環會消耗CPU。

1. 自旋鎖的時間閾值

自旋鎖的目的是爲了佔着CPU的資源不釋放，等到獲取到鎖當即進行處理。可是如何去選擇自旋的執行時間呢？若是自旋執行時間太長，會有大量的線程處於自旋狀態佔用CPU資源，進而會影響總體系統的性能。所以自旋的週期選的額外重要！

JVM對於自旋週期的選擇，jdk1.5這個限度是必定的寫死的，在1.6引入了適應性自旋鎖，適應性自旋鎖意味着自旋的時間不在是固定的了，而是由前一次在同一個鎖上的自旋時間以及鎖的擁有者的狀態來決定，基本認爲一個線程上下文切換的時間是最佳的一個時間，同時JVM還針對當前CPU的負荷狀況作了較多的優化
1. 若是平均負載小於CPUs則一直自旋
2. 若是有超過(CPUs/2)個線程正在自旋，則後來線程直接阻塞
3. 若是正在自旋的線程發現Owner發生了變化則延遲自旋時間（自旋計數）或進入阻塞
4. 若是CPU處於節電模式則中止自旋
5. 自旋時間的最壞狀況是CPU的存儲延遲（CPU A存儲了一個數據，到CPU B得知這個數據直接的時間差）
6. 自旋時會適當放棄線程優先級之間的差別

自旋鎖的優勢

自旋鎖不會使線程狀態發生切換，一直處於用戶態，即線程一直都是active的；不會使線程進入阻塞狀態，減小了沒必要要的上下文切換，執行速度快。
非自旋鎖在獲取不到鎖的時候會進入阻塞狀態，從而進入內核態，當獲取到鎖的時候須要從內核態恢復，須要線程上下文切換。（線程被阻塞後便進入內核（Linux）調度狀態，這個會致使系統在用戶態與內核態之間來回切換，嚴重影響鎖的性能）

自旋鎖使用實例

public class SpinLock {
    private AtomicReference<Thread> cas = new AtomicReference<Thread>();
    public void lock() {
        Thread current = Thread.currentThread();
        // 利用CAS
        while (!cas.compareAndSet(null, current)) {
            // DO nothing
        }
    }
    public void unlock() {
        Thread current = Thread.currentThread();
        cas.compareAndSet(current, null);
    }
}
複製代碼

ock（)方法利用的CAS，當第一個線程A獲取鎖的時候，可以成功獲取到，不會進入while循環，若是此時線程A沒有釋放鎖，另外一個線程B又來獲取鎖，此時因爲不知足CAS，因此就會進入while循環，不斷判斷是否知足CAS，直到A線程調用unlock方法釋放了該鎖。

可重入的自旋鎖和不可重入的自旋鎖

上面代碼是不支持重入的，它是不支持重入的，即當一個線程第一次已經獲取到了該鎖，在鎖釋放以前又一次從新獲取該鎖，第二次就不能成功獲取到。因爲不知足CAS，因此第二次獲取會進入while循環等待，而若是是可重入鎖，第二次也是應該可以成功獲取到的
並且，即便第二次可以成功獲取，那麼當第一次釋放鎖的時候，第二次獲取到的鎖也會被釋放，而這是不合理的。爲了實現可重入鎖，咱們須要引入一個計數器，用來記錄獲取鎖的線程數。

ublic class ReentrantSpinLock {
    private AtomicReference<Thread> cas = new AtomicReference<Thread>();
    private int count;
    public void lock() {
        Thread current = Thread.currentThread();
        if (current == cas.get()) { // 若是當前線程已經獲取到了鎖，線程數增長一，而後返回
            count++;
            return;
        }
        // 若是沒獲取到鎖，則經過CAS自旋
        while (!cas.compareAndSet(null, current)) {
            // DO nothing
        }
    }
    public void unlock() {
        Thread cur = Thread.currentThread();
        if (cur == cas.get()) {
            if (count > 0) {// 若是大於0，表示當前線程屢次獲取了該鎖，釋放鎖經過count減一來模擬
                count--;
            } else {// 若是count==0，能夠將鎖釋放，這樣就能保證獲取鎖的次數與釋放鎖的次數是一致的了。
                cas.compareAndSet(cur, null);
            }
        }
    }
}
複製代碼