Java併發程式設計(05)：悲觀鎖和樂觀鎖機制

知了一笑發表於2020-06-18
Java程式設計

本文原始碼：GitHub·點這裡 || GitEE·點這裡

一、資源和加鎖

1、場景描述

多執行緒併發訪問同一個資源問題，假如執行緒A獲取變數之後修改變數值，執行緒C在此時也獲取變數值並且修改，兩個執行緒同時併發處理一個變數，就會導致併發問題。

這種並行處理資料庫的情況在實際的業務開發中很常見，兩個執行緒先後修改資料庫的值，導致資料有問題，該問題復現的概率不大，處理的時候需要對整個模組體系有概念，才能容易定位問題。

2、演示案例

public class LockThread01 {
    public static void main(String[] args) {
        CountAdd countAdd = new CountAdd() ;
        AddThread01 addThread01 = new AddThread01(countAdd) ;
        addThread01.start();
        AddThread02 varThread02 = new AddThread02(countAdd) ;
        varThread02.start();
    }
}
class AddThread01 extends Thread {
    private CountAdd countAdd  ;
    public AddThread01 (CountAdd countAdd){
        this.countAdd = countAdd ;
    }
    @Override
    public void run() {
        countAdd.countAdd(30);
    }
}
class AddThread02 extends Thread {
    private CountAdd countAdd  ;
    public AddThread02 (CountAdd countAdd){
        this.countAdd = countAdd ;
    }
    @Override
    public void run() {
        countAdd.countAdd(10);
    }
}
class CountAdd {
    private Integer count = 0 ;
    public void countAdd (Integer num){
        try {
            if (num == 30){
                count = count + 50 ;
                Thread.sleep(3000);
            } else {
                count = count + num ;
            }
            System.out.println("num="+num+";count="+count);
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

這裡案例演示多執行緒併發修改count值，導致和預期不一致的結果，這是多執行緒併發下最常見的問題，尤其是在併發更新資料時。

出現併發的情況時，就需要通過一定的方式或策略來控制在併發情況下資料讀寫的準確性，這被稱為併發控制，實現併發控制手段也很多，最常見的方式是資源加鎖，還有一種簡單的實現策略：修改資料前讀取資料，修改的時候加入限制條件，保證修改的內容在此期間沒有被修改。

二、鎖的概念簡介

1、鎖機制簡介

併發程式設計中一個最關鍵的問題，多執行緒併發處理同一個資源，防止資源使用的衝突一個關鍵解決方法，就是在資源上加鎖：多執行緒序列化訪問。鎖是用來控制多個執行緒訪問共享資源的方式，鎖機制能夠讓共享資源在任意給定時刻只有一個執行緒任務訪問，實現執行緒任務的同步互斥，這是最理想但效能最差的方式，共享讀鎖的機制允許多工併發訪問資源。

2、悲觀鎖

悲觀鎖，總是假設每次每次被讀取的資料會被修改，所以要給讀取的資料加鎖，具有強烈的資源獨佔和排他特性，在整個資料處理過程中，將資料處於鎖定狀態，例如synchronized關鍵字的實現就是悲觀機制。

悲觀鎖的實現，往往依靠資料庫提供的鎖機制，只有資料庫層提供的鎖機制才能真正保證資料訪問的排他性，否則，即使在本系統中實現了加鎖機制，也無法保證外部系統不會修改資料，悲觀鎖主要分為共享讀鎖和排他寫鎖。

排他鎖基本機制：又稱寫鎖，允許獲取排他鎖的事務更新資料，阻止其他事務取得相同的資源的共享讀鎖和排他鎖。若事務T對資料物件A加上寫鎖，事務T可以讀A也可以修改A，其他事務不能再對A加任何鎖，直到T釋放A上的寫鎖。

3、樂觀鎖

樂觀鎖相對悲觀鎖而言，採用更加寬鬆的加鎖機制。悲觀鎖大多數情況下依靠資料庫的鎖機制實現，以保證操作最大程度的獨佔性。但隨之而來的就是資料庫效能的大量開銷，特別是對長事務的開銷非常的佔資源，樂觀鎖機制在一定程度上解決了這個問題。

樂觀鎖大多是基於資料版本記錄機制實現，為資料增加一個版本標識，在基於資料庫表的版本解決方案中，一般是通過為資料庫表增加一個version欄位來實現。讀取出資料時，將此版本號一同讀出，之後更新時，對此版本號加一。此時，將提交資料的版本資料與資料庫表對應記錄的當前版本資訊進行比對，如果提交的資料版本號等於資料庫表當前版本號，則予以更新，否則認為是過期資料。樂觀鎖機制在高併發場景下，可能會導致大量更新失敗的操作。

樂觀鎖的實現是策略層面的實現：CAS(Compare-And-Swap)。當多個執行緒嘗試使用CAS同時更新同一個變數時，只有其中一個執行緒能成功更新變數的值，而其它執行緒都失敗，失敗的執行緒並不會被掛起，而是被告知這次競爭中失敗，並可以再次嘗試。

4、機制對比

悲觀鎖本身的實現機制就以損失效能為代價，多執行緒爭搶，加鎖、釋放鎖會導致比較多的上下文切換和排程延時，加鎖的機制會產生額外的開銷，還有增加產生死鎖的概率，引發效能問題。

樂觀鎖雖然會基於對比檢測的手段判斷更新的資料是否有變化，但是不確定資料是否變化完成，例如執行緒1讀取的資料是A1，但是執行緒2操作A1的值變化為A2，然後再次變化為A1，這樣執行緒1的任務是沒有感知的。

悲觀鎖每一次資料修改都要上鎖，效率低，寫資料失敗的概率比較低，比較適合用在寫多讀少場景。

樂觀鎖並未真正加鎖，效率高，寫資料失敗的概率比較高，容易發生業務形異常，比較適合用在讀多寫少場景。

是選擇犧牲效能，還是追求效率，要根據業務場景判斷，這種選擇需要依賴經驗判斷，不過隨著技術迭代，資料庫的效率提升，叢集模式的出現，效能和效率還是可以兩全的。

三、Lock基礎案例

1、Lock方法說明

lock：執行一次獲取鎖，獲取後立即返回；

lockInterruptibly：在獲取鎖的過程中可以中斷；

tryLock：嘗試非阻塞獲取鎖，可以設定超時時間，如果獲取成功返回true，有利於執行緒的狀態監控；

unlock：釋放鎖，清理執行緒狀態；

newCondition：獲取等待通知元件，和當前鎖繫結；

2、應用案例

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockThread02 {
    public static void main(String[] args) {
        LockNum lockNum = new LockNum() ;
        LockThread lockThread1 = new LockThread(lockNum,"TH1");
        LockThread lockThread2 = new LockThread(lockNum,"TH2");
        LockThread lockThread3 = new LockThread(lockNum,"TH3");
        lockThread1.start();
        lockThread2.start();
        lockThread3.start();
    }
}
class LockNum {
    private Lock lock = new ReentrantLock() ;
    public void getNum (){
        lock.lock();
        try {
            for (int i = 0 ; i < 3 ; i++){
                System.out.println("ThreadName:"+Thread.currentThread().getName()+";i="+i);
            }
        } finally {
            lock.unlock();
        }
    }
}
class LockThread extends Thread {
    private LockNum lockNum ;
    public LockThread (LockNum lockNum,String name){
        this.lockNum = lockNum ;
        super.setName(name);
    }
    @Override
    public void run() {
        lockNum.getNum();
    }
}

這裡多執行緒基於Lock鎖機制，分別依次執行任務，這是Lock的基礎用法，各種API的詳解，下次再說。

3、與synchronized對比

基於synchronized實現的鎖機制，安全性很高，但是一旦執行緒失敗，直接丟擲異常，沒有清理執行緒狀態的機會。顯式的使用Lock語法，可以在finally語句中最終釋放鎖，維護相對正常的執行緒狀態，在獲取鎖的過程中，可以嘗試獲取，或者嘗試獲取鎖一段時間。

四、原始碼地址

GitHub·地址
https://github.com/cicadasmile/java-base-parent
GitEE·地址
https://gitee.com/cicadasmile/java-base-parent

推薦閱讀：Java基礎系列

序號 文章標題
A01 Java基礎：基本資料型別，核心點整理
A02 Java基礎：特殊的String類，和相關擴充套件API
B01 Java併發：執行緒的建立方式，狀態週期管理
B02 Java併發：執行緒核心機制，基礎概念擴充套件
B03 Java併發：多執行緒併發訪問，同步控制
B04 Java併發：執行緒間通訊，等待/通知機制

相關文章