Java併發編程(05)：悲觀鎖和樂觀鎖機制

本文源碼：GitHub·點這裏 || GitEE·點這裏

1、資源和加鎖

一、場景描述

多線程併發訪問同一個資源問題，假如線程A獲取變量以後修改變量值，線程C在此時也獲取變量值而且修改，兩個線程同時併發處理一個變量，就會致使併發問題。

這種並行處理數據庫的狀況在實際的業務開發中很常見，兩個線程前後修改數據庫的值，致使數據有問題，該問題復現的機率不大，處理的時候須要對整個模塊體系有概念，才能容易定位問題。

二、演示案例

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值，致使和預期不一致的結果，這是多線程併發下最多見的問題，尤爲是在併發更新數據時。

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

2、鎖的概念簡介

一、鎖機制簡介

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

二、悲觀鎖

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

悲觀鎖的實現，每每依靠數據庫提供的鎖機制，只有數據庫層提供的鎖機制才能真正保證數據訪問的排他性，不然，即便在本系統中實現了加鎖機制，也沒法保證外部系統不會修改數據，悲觀鎖主要分爲共享讀鎖和排他寫鎖。

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

三、樂觀鎖

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

樂觀鎖大可能是基於數據版本記錄機制實現，爲數據增長一個版本標識，在基於數據庫表的版本解決方案中，通常是經過爲數據庫表增長一個version字段來實現。讀取出數據時，將此版本號一同讀出，以後更新時，對此版本號加一。此時，將提交數據的版本數據與數據庫表對應記錄的當前版本信息進行比對，若是提交的數據版本號等於數據庫表當前版本號，則予以更新，不然認爲是過時數據。樂觀鎖機制在高併發場景下，可能會致使大量更新失敗的操做。

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

四、機制對比

悲觀鎖自己的實現機制就以損失性能爲代價，多線程爭搶，加鎖、釋放鎖會致使比較多的上下文切換和調度延時，加鎖的機制會產生額外的開銷，還有增長產生死鎖的機率，引起性能問題。

樂觀鎖雖然會基於對比檢測的手段判斷更新的數據是否有變化，可是不肯定數據是否變化完成，例如線程1讀取的數據是A1，可是線程2操做A1的值變化爲A2，而後再次變化爲A1，這樣線程1的任務是沒有感知的。

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

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

是選擇犧牲性能，仍是追求效率，要根據業務場景判斷，這種選擇須要依賴經驗判斷，不過隨着技術迭代，數據庫的效率提高，集羣模式的出現，性能和效率仍是能夠兩全的。

3、Lock基礎案例

一、Lock方法說明

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

lockInterruptibly：在獲取鎖的過程當中能夠中斷；

tryLock：嘗試非阻塞獲取鎖，能夠設置超時時間，若是獲取成功返回true，有利於線程的狀態監控；

unlock：釋放鎖，清理線程狀態；

newCondition：獲取等待通知組件，和當前鎖綁定；

二、應用案例

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的詳解，下次再說。

三、與synchronized對比

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

4、源代碼地址

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併發：線程間通訊，等待/通知機制