本文原始碼：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基礎系列

標籤：Java

上一篇：Java的兩把鎖淺析

下一篇：Python中的三個騷操作和黑魔法技術，裝逼必備