bilibili尚硅谷周阳老师JUC并发编程与源码分析课程笔记第十三章——ReentrantLock、ReentrantReadWriteLock、StampedLock讲解

ReentrantLock、ReentrantReadWriteLock、StampedLock讲解

本章路线总纲

无锁——>独占锁——>读写锁——>邮戳锁

关于锁的面试题

• 你知道Java里面有那些锁？
• 你说说你用过的锁，锁饥饿问题是什么？
• 有没有比读写锁更快的锁？
• StampedLock知道吗？（邮戳锁/票据锁）
• ReentrantReadWriteLock有锁降级机制，你知道吗？
• …

简单聊聊ReentrantReadWriteLock

类继承关系

是什么

读写锁说明

读写锁的定义：一个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程

一体两面，读写互斥，读读共享；刀刃、刀背互斥（写的时候不可以读，读的时候不能写）

再说说演变

无锁无序->加锁->读写锁->邮戳锁

读写锁意义和特点

它只允许读读共存，而读写和写写依然是互斥的，大多实际场景是**”读/读“线程间不存在互斥关系**，只有”读/写“线程或者”写/写“线程间的操作是需要互斥的，因此引入了 ReentrantReadWriteLock

一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但是不能同时存在写锁和读锁，也即一个资源可以被多个读操作访问，或一个写操作访问，但两者不能同时进行

只有在读多写少情景之下，读写锁才具有较高的性能体现

特点

可重入

读写兼顾

案例演示

ReentrantLock实现读写操作

package com.bilibili.juc.reentrantreadwritelock;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockDemo {
   
    public static void main(String[] args) {
   
        MyResource myResource = new MyResource();

        for (int i = 0; i < 10; i++) {
   
            int finalI = i;
            new Thread(() -> {
   
                myResource.write(finalI + "", finalI + "");
            }, String.valueOf(i)).start();
        }

        for (int i = 0; i < 10; i++) {
   
            int finalI = i;
            new Thread(() -> {
   
                myResource.read(finalI + "");
            }, String.valueOf(i)).start();
        }
    }
}


// 资源类，模拟一个简单的缓存
class MyResource {
   
    Map<String, String> map = new HashMap<>();
    // ReentrantLock等价于synchronized，之前讲解过
    Lock lock = new ReentrantLock();

    public void write(String key, String value) {
   
        lock.lock();
        try {
   
            System.out.println(Thread.currentThread().getName() + "\t" + "正在写入");
            map.put(key, value);
            try {
   
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "完成写入");
        } finally {
   
            lock.unlock();
        }
    }

    public void read(String key) {
   
        lock.lock();
        try {
   
            System.out.println(Thread.currentThread().getName() + "\t" + "正在读取");
            String result = map.get(key);
            try {
   
                TimeUnit.MILLISECONDS.sleep(200);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "完成读取" + "\t" + result);
        } finally {
   
            lock.unlock();
        }
    }
}

输出结果：
1	正在写入
1	完成写入
0	正在写入
0	完成写入
2	正在写入
2	完成写入
3	正在写入
3	完成写入
4	正在写入
4	完成写入
5	正在写入
5	完成写入
6	正在写入
6	完成写入
7	正在写入
7	完成写入
8	正在写入
8	完成写入
0	正在读取
0	完成读取	0
1	正在读取
1	完成读取	1
9	正在写入
9	完成写入
2	正在读取
2	完成读取	2
3	正在读取
3	完成读取	3
4	正在读取
4	完成读取	4
5	正在读取
5	完成读取	5
6	正在读取
6	完成读取	6
7	正在读取
7	完成读取	7
8	正在读取
8	完成读取	8
9	正在读取
9	完成读取	9

结论

使用ReentrantLock实现读写操作，任何一个线程正在读/写的时候不允许被打断

ReentrantReadWriteLock实现读写操作1

package com.bilibili.juc.reentrantreadwritelock;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockDemo {
   
    public static void main(String[] args) {
   
        MyResource myResource = new MyResource();

        for (int i = 0; i < 10; i++) {
   
            int finalI = i;
            new Thread(() -> {
   
                myResource.write(finalI + "", finalI + "")