ReentrantReadWriteLock讀寫鎖

ReentrantReadWriteLock讀寫鎖

樂觀鎖和悲觀鎖

樂觀鎖

樂觀鎖，就是給需要共用的數據，添加一個版本號version，例如1，每次有線程更新共用數據後，version+1，每次線程進行數據更新時，要比較當前線程持有的數據的版本號，相等則修改，不相等則不修改，支持併發訪問。

悲觀鎖

悲觀鎖，就是每次只能有一個線程，訪問共用的數據，其他線程都阻塞，只有當前線程結束，才會釋放鎖，其他線程中的一個才能訪問，不支持併發訪問。

表鎖和行鎖

表鎖

線程涉及到資料庫的修改時，其他線程不能修改整個表中的任意行數據，就是表鎖，表鎖不會出現行鎖。

行鎖

線程涉及到資料庫的修改時，只鎖當前的一行，是行鎖，可能會出現死鎖。

讀寫鎖

讀鎖是共用鎖，寫鎖是獨占鎖。都可能出現死鎖。
讀寫鎖，一個資源可以被多個讀線程訪問，或者一個寫線程訪問，但是不能同時存在讀寫線程，讀寫是互斥的，讀讀是共用的。

案例及代碼實現

//1.定義資源類
class MyCache {

    //volatile關鍵字，共用的數據，在一個線程修改後，被其他線程訪問到
    private volatile HashMap<String, Object> hashMap = new HashMap<>();

    private ReadWriteLock rwLock = new ReentrantReadWriteLock();

    //2.定義操作資源類的方法
    public Object get(String key) {
        rwLock.readLock().lock();//讀鎖
        Object result = null;
        try {
            System.out.println(Thread.currentThread().getName() + "正在讀取值" + key);

            TimeUnit.MILLISECONDS.sleep(300);
            result = hashMap.get(key);
            System.out.println(Thread.currentThread().getName() + "讀取值完成" + key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            rwLock.readLock().unlock();
        }
        return result;
    }

    public void put(String key, Object value) {
        rwLock.writeLock().lock();//寫鎖
        try {
            System.out.println(Thread.currentThread().getName() + "正在添加值" + key);
            TimeUnit.MILLISECONDS.sleep(300);
            hashMap.put(key, value);
            System.out.println(Thread.currentThread().getName() + "添加值完成" + key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            rwLock.writeLock().unlock();
        }

    }


}

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache cache = new MyCache();
        
        //創建線程，向緩存中添加值
        for (int i = 0; i < 5; i++) {
            final int num = i;
            new Thread(() -> {
                cache.put(num + "", num);
            }, String.valueOf(i)).start();
        }

        //創建線程，向緩存中獲取值
        for (int i = 0; i < 5; i++) {
            final int num = i;
            new Thread(() -> {
                cache.get(num + "");
            }, String.valueOf(i)).start();
        }

    }
}

讀寫鎖的演變

讀寫鎖的降級

降級案例及代碼

/**
 * @author 長名06
 * @version 1.0
 * 讀寫鎖降級演示
 */
public class ReadWriteLockDownLevelDemo {
    public static void main(String[] args) {
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();//寫鎖
        ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();//讀鎖
		//先讀後寫，獲取讀鎖後，就獲取不到寫鎖，線程阻塞

        //1.獲取寫鎖
        writeLock.lock();
        System.out.println("獲取寫鎖");

        //2.獲取讀鎖
        readLock.lock();
        System.out.println("獲取讀鎖");

        //3.釋放寫鎖
        writeLock.unlock();

        //4.釋放讀鎖
        readLock.unlock();
    }
}

小結

• 1.線上程持有讀鎖的情況下，該線程不能取得寫鎖，因為獲取寫鎖時，如果寫鎖對應的讀鎖被占用，就馬上獲取失敗，不管讀鎖是否是當前線程持有(原因，此寫鎖對應的讀鎖被線程持有，證明有線程正在讀取數據，這是為了避免出現幻讀現象)。
• 2.線上程持有寫鎖的情況下，該線程可以繼續獲取讀鎖。獲取讀鎖時，如果發現寫鎖被占用，只有寫鎖沒有被當前線程占用的情況下才會獲取失敗。
• 原因，讀鎖是共用鎖，即當某個線程獲取讀鎖時，可能有其他線程同時也在持有讀鎖；而對於已獲取寫鎖的線程，它一定獨占了寫鎖因此可以繼續讓其獲取讀鎖，當該線程同時獲取了寫鎖和讀鎖時，還可以先釋放寫鎖繼續持有讀鎖，這樣就稱為寫鎖的降級。
  只是為了記錄自己的學習歷程，且本人水平有限，不對之處，請指正。