JUC并发编程第十三章——读写锁、邮戳锁

本章路线总纲

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

1 关于锁的面试题

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

2 简单聊聊ReentrantReadWriteLock

类图：

读写锁的演变情况：

2.1 是什么？

读写锁说明

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

演变

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

读写锁意义和特点

• 读写锁只允许读读共存，而读写和写写依然是互斥的，恰好大多实际场景是”读/读“线程间不存在互斥关系，只有”读/写“线程或者”写/写“线程间的操作是需要互斥的，因此引入了 ReentrantReadWriteLock
• 一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但是不能同时存在写锁和读锁，也即资源可以被多个读操作访问，或一个写操作访问，但两者不能同时进行。
• 只有在读多写少情景之下，读写锁才具有较高的性能体现。

2.2 特点

可重入、读写兼顾

结论：一体两面，读写互斥，读读共享，读没有完成的时候其他线程写锁无法获得

ReentrantReadWriteLock的缺点：

1. 锁饥饿问题：

• ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了，因此当前有可能会一直存在读锁，而无法获得写锁。

2. 锁降级：

• 将写锁降级为读锁------>遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级为读锁
• 如果一个线程持有了写锁，在没有释放写锁的情况下，它还可以继续获得读锁。这就是写锁的降级，降级成为了读锁。
• 如果释放了写锁，那么就完全转换为读锁
• 如果有线程在读，那么写线程是无法获取写锁的，是悲观锁的策略

• 

2.3 读写锁案例

• 使用读写锁之前，使用synchronized的情况

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

        //开启10个线程，写入数据
        for (int i = 1; i <= 10; i++) {
            int finalI = i;
            new Thread(() -> {
                cache.write(finalI + "", finalI + "");
            }, String.valueOf(i)).start();
        }

        //开启10个线程，读取数据
        for (int i = 1; i <= 10; i++) {
            int finalI = i;
            new Thread(() -> {
                cache.read(finalI + "");
            }, String.valueOf(i)).start();
        }
    }
}

//模拟一个缓存资源类，有读写两种功能
class MyCache {

    HashMap<String, String> map = new HashMap<>();

     ReentrantLock lock = new ReentrantLock();

    //读写都加锁
    public void write(String key, String value) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "线程开始写入数据...");
            //延迟500ms模拟业务耗时，同时可以看出读写不能共同执行 (因为运行结果是先打印一个线程写入，再打印对应线程写入完成)
            TimeUnit.MILLISECONDS.sleep(500);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "线程完成写入数据!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void read(String key) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "线程开始读取数据...");
            String val = map.get(key);
            TimeUnit.MILLISECONDS.sleep(200);
            System.out.println(Thread.currentThread().getName() + "线程读取到的数据是：\t" + val);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}
运行结果：
1线程开始写入数据...
1线程完成写入数据!
2线程开始写入数据...
2线程完成写入数据!
3线程开始写入数据...
3线程完成写入数据!
4线程开始写入数据...
4线程完成写入数据!
5线程开始写入数据...
5线程完成写入数据!
6线程开始写入数据...
6线程完成写入数据!
7线程开始写入数据...
7线程完成写入数据!
9线程开始写入数据...
9线程完成写入数据!
8线程开始写入数据...
8线程完成写入数据!
10线程开始写入数据...
10线程完成写入数据!
1线程开始读取数据...
1线程读取到的数据是：	1
2线程开始读取数据...
2线程读取到的数据是：	2
3线程开始读取数据...
3线程读取到的数据是：	3
4线程开始读取数据...
4线程读取到的数据是：	4
5线程开始读取数据...
5线程读取到的数据