[Java 并發(fā)]讀寫鎖ReedWriteLock/StampedLock

這篇看一下JUC包提供的讀寫鎖(共享鎖/獨(dú)占鎖)吹榴。

之前我們都知道在一個(gè)變量被讀或者寫數(shù)據(jù)的時(shí)候每次只有一個(gè)線程可以執(zhí)行洒放，那么今天我們來看一下讀寫鎖净当，讀寫兩不誤ReadWriteLock衙伶。

這里有兩個(gè)概念:

獨(dú)占鎖:

指該鎖一次只能被一個(gè)線程所持有。(ReentrantLock和Synchronized都屬于獨(dú)占鎖)叨咖。

共享鎖:

指該鎖可被多個(gè)線程所持有瘩例。

ReentrantReadWriteLock其讀鎖是共享鎖，共寫鎖是獨(dú)占鎖芒澜。

讀鎖的共享鎖可以保證并發(fā)讀是非常高效的，讀寫创淡，寫讀痴晦，寫寫的過程是互斥的。

直接使用ReentrantReadWriteLock寫段代碼看一下:

class CacheList{
    private volatile ArrayList<Long> list = new ArrayList<>();

    private ReadWriteLock lock = new ReentrantReadWriteLock();

    public void put(Long value) {
        try {
            lock.writeLock().lock(); // 獲取寫鎖
            System.out.println(Thread.currentThread().getName() + " \t 開始寫入數(shù)據(jù): \t" + value);

            TimeUnit.SECONDS.sleep(2); // 阻塞兩秒
            this.list.add(value);

            System.out.println(Thread.currentThread().getName() + " \t 寫入數(shù)據(jù)完成");
            lock.writeLock().unlock(); // 釋放寫鎖
        }catch (Exception ex) {
            ex.printStackTrace();
        }

    }

    public void get() {
        try {
            lock.readLock().lock(); // 獲取讀鎖
            System.out.println(Thread.currentThread().getName() + " \t 開始讀取數(shù)據(jù)");

            TimeUnit.SECONDS.sleep(2); // 阻塞兩秒
            String collect = this.list.stream().map(String::valueOf).collect(Collectors.joining(","));

            System.out.println(Thread.currentThread().getName() + " \t 讀取數(shù)據(jù)完成: " + collect);
            lock.readLock().unlock(); // 釋放讀鎖
        } catch (Exception ex) {
            ex.printStackTrace();
        }

    }
}


public class ReadWriteLockDemo {

    public static void main(String[] args) {
        CacheList cacheMap = new CacheList();

        IntStream.range(0, 5)
                .forEach(i -> new Thread(() ->  cacheMap.put(System.currentTimeMillis()),
                        "寫線程:" + i).start());

        IntStream.range(0, 5)
                .forEach(i -> new Thread(cacheMap::get,
                        "讀線程:" + i).start());
    }
}

上方代碼運(yùn)行效果如下:

image-20191224235044062

可以看到運(yùn)行結(jié)果琳彩，紅色圈住的地方我們可以看到當(dāng)使用寫鎖的時(shí)候不管是哪個(gè)線程進(jìn)來都會(huì)使其他線程在外等待誊酌，直到鎖被釋放才能擁有獲取權(quán)限。而藍(lán)色部分是使用了讀鎖露乏，所有線程可以同時(shí)獲取允許多個(gè)線程同時(shí)擁有鎖碧浊。

注:

但是會(huì)出現(xiàn)寫一個(gè)問題，就是寫?zhàn)囸I現(xiàn)象瘟仿，上方我們是先運(yùn)行了所有的寫線程箱锐，讀線程是在寫線程后執(zhí)行的，假如讀線程的數(shù)量大于寫線程數(shù)量的話劳较，因鎖的大概率都被讀線程執(zhí)行了驹止，就會(huì)造成一種寫?zhàn)囸I現(xiàn)象，寫線程無法滿足大量讀線程的讀操作观蜗，因?yàn)閷懢€程少的時(shí)候會(huì)搶不到鎖臊恋。

然而在JDK1.8新增了一個(gè)鎖叫做StampedLock鎖,他是對ReadWriteLock的改進(jìn)。

上邊也說了ReadWrite鎖可能會(huì)出現(xiàn)寫?zhàn)囸I墓捻，而StampedLock就是為了解決這個(gè)問題鎖設(shè)計(jì)的抖仅，StampedLock可以選擇使用樂觀鎖或悲觀鎖。

樂觀鎖:每次去拿數(shù)據(jù)的時(shí)候，并不是獲取鎖對象撤卢，而是為了判斷標(biāo)記為(stamp)是否又被修改环凿，如果有修改就再去獲取讀一次。

悲觀鎖:每次拿數(shù)據(jù)的時(shí)候都去獲取鎖凸丸。

通過樂觀鎖拷邢，當(dāng)寫線程沒有寫數(shù)據(jù)的時(shí)候，標(biāo)志位stamp并沒有改變屎慢，所以即使有再多的讀線程讀數(shù)據(jù)瞭稼，他都可以讀取，而無需獲取鎖腻惠，這就不會(huì)使得寫線程搶不到鎖了环肘。

stamp類似一個(gè)時(shí)間戳的作用，每次寫的時(shí)候?qū)ζ?1來改變被操作對象的stamp值集灌。

通過代碼來操作下看一看悔雹，先寫一個(gè)出現(xiàn)寫?zhàn)囸I的情況，模擬19個(gè)讀線程讀取數(shù)據(jù)欣喧，1個(gè)寫線程寫數(shù)據(jù)腌零。

class CacheList{
    private volatile ArrayList<Long> list = new ArrayList<>();

    private StampedLock lock = new StampedLock();

    public void put(Long value) {
        long stamped = -1; // 設(shè)置標(biāo)記位
        try {
            stamped = lock.writeLock(); // 獲取寫鎖
            System.out.println(Thread.currentThread().getName() + " \t 開始寫入數(shù)據(jù): \t" + value);

            TimeUnit.SECONDS.sleep(2); // 阻塞兩秒
            this.list.add(value);

            System.out.println(Thread.currentThread().getName() + " \t 寫入數(shù)據(jù)完成");
        }catch (Exception ex) {
            ex.printStackTrace();
        }finally {
            lock.unlockWrite(stamped); // 釋放寫鎖
        }

    }

    public void get() {
        long stamped = -1; // 設(shè)置標(biāo)記位
        try {
            stamped = lock.readLock(); // 獲取讀鎖  -->這里是悲觀鎖實(shí)現(xiàn)  --> stamped重新賦值標(biāo)記位
            System.out.println(Thread.currentThread().getName() + " \t 開始讀取數(shù)據(jù)");

            TimeUnit.SECONDS.sleep(2); // 阻塞兩秒
            String collect = this.list.stream().map(String::valueOf).collect(Collectors.joining(","));

            System.out.println(Thread.currentThread().getName() + " \t 讀取數(shù)據(jù)完成: " + collect);
        } catch (Exception ex) {
            ex.printStackTrace();
        }finally {
            lock.unlockRead(stamped); // 釋放讀鎖 --> 這里我們放入一個(gè)標(biāo)記位
        }

    }
}

public class ReadWriteLockDemo2 {

    public static void main(String[] args) {
        CacheList cacheMap = new CacheList();

        IntStream.range(0, 19)
                .forEach(i -> new Thread(cacheMap::get,
                        "讀線程:" + i).start());

        IntStream.range(0, 1)
                .forEach(i -> new Thread(() ->  cacheMap.put(System.currentTimeMillis()),
                        "寫線程:" + i).start());
    }
}

上邊使用了StampedLock做了一個(gè)讀鎖悲觀鎖的實(shí)現(xiàn)，模擬了20個(gè)線程唆阿，假設(shè)了寫線程因不能及時(shí)寫入數(shù)據(jù)造成寫?zhàn)囸I現(xiàn)象益涧。我們看一下運(yùn)行結(jié)果。

image-20191225224738709

可以看到結(jié)果驯鳖，讀鎖都可以同時(shí)獲取鎖闲询，就算寫線程沒有寫入數(shù)據(jù)所有讀線程還是在搶占鎖，使用ReadWriteLock也是會(huì)出現(xiàn)同樣的現(xiàn)象浅辙，寫?zhàn)囸I扭弧。

下面我們使用樂觀鎖，每次判斷標(biāo)記位是否被修改记舆，如果有被修改就再進(jìn)行上鎖然后重新讀取鸽捻。

class CacheList{
    private volatile ArrayList<Long> list = new ArrayList<>();

    private StampedLock lock = new StampedLock();

    public void put(Long value) {
        long stamped = -1; // 設(shè)置標(biāo)記位
        try {
            stamped = lock.writeLock(); // 獲取寫鎖
            System.out.println(Thread.currentThread().getName() + " \t 開始寫入數(shù)據(jù): \t" + value);

            TimeUnit.SECONDS.sleep(2); // 阻塞兩秒
            this.list.add(value);

            System.out.println(Thread.currentThread().getName() + " \t 寫入數(shù)據(jù)完成");
        }catch (Exception ex) {
            ex.printStackTrace();
        }finally {
            lock.unlockWrite(stamped); // 釋放寫鎖
        }

    }

    public void get() {
        // 這里使用了樂觀鎖，每次去判斷標(biāo)記位是否被改變泽腮，如果寫線程有修改此值會(huì)被修改
        long stamped = lock.tryOptimisticRead();
        try {
            System.out.println(Thread.currentThread().getName() + " \t 開始讀取數(shù)據(jù)");
            TimeUnit.SECONDS.sleep(2); // 阻塞兩秒
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        // 讀取值
        String collect = this.list.stream().map(String::valueOf).collect(Collectors.joining(","));

        // 判斷以下標(biāo)記位是否被修改泊愧，被修改就會(huì)返回false，說明有寫線程寫入了新數(shù)據(jù)
        // 那么重新獲取鎖并去讀取值盛正，否則直接使用上面讀取的值
        if (!lock.validate(stamped)){
            try {
                stamped = lock.readLock();
                collect = this.list.stream().map(String::valueOf).collect(Collectors.joining(","));
            }catch (Exception ex) {
                ex.printStackTrace();
            }finally {
                lock.unlockRead(stamped);
            }

        }

        System.out.println(Thread.currentThread().getName() + " \t 讀取數(shù)據(jù)完成: " + collect);

    }
}

public class ReadWriteLockDemo2 {

    public static void main(String[] args) {
        CacheList cacheMap = new CacheList();

        IntStream.range(0, 19)
                .forEach(i -> new Thread(cacheMap::get,
                        "讀線程:" + i).start());

        IntStream.range(0, 1)
                .forEach(i -> new Thread(() ->  cacheMap.put(System.currentTimeMillis()),
                        "寫線程:" + i).start());
    }
}

直接看運(yùn)行結(jié)果:

image-20191225231803933

主要看get方法删咱，get方法開始調(diào)用StampedLock的tryOptimisticRead方法來獲取標(biāo)志位stamp，獲取樂觀鎖那塊并不是真的去上鎖(所以不會(huì)阻塞寫操作),然后直接去讀數(shù)據(jù)豪筝。接著通過validate方法來判斷標(biāo)志位是否被修改了痰滋，修改了就在進(jìn)行獲取鎖進(jìn)行讀取摘能，沒被修改則會(huì)返回true直接使用上邊獲取到的值。

StampedLock解決了在沒有新數(shù)據(jù)寫入時(shí)敲街，由于過多讀操作搶奪鎖而使得寫操作一直獲取不到鎖無法寫入新數(shù)據(jù)的問題团搞。