读写锁

A.什么是读写锁？
读操作共享资源，写操作独占资源

B.手写一个读写锁

import java.util.HashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class cache {
    HashMap<String, String> map = new HashMap<>();
    ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();//读写锁

    //写方法
    public void put(String key, String value) throws InterruptedException {
        rwlock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName() + ":准备写入值");
            //为了验证其他线程并不会在某个线程写操作时获得锁
            Thread.sleep(300);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + ":写操作完成");
        }finally {
            rwlock.writeLock().unlock();
        }
    }

    //读方法
    public void get(String key)
    {
        rwlock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+":开始读");
            Thread.sleep(300);
            String res=map.get(key);
            System.out.println(Thread.currentThread().getName()+":结束读，结果是"+res);
        }catch(Exception e)
        {
            e.printStackTrace();
        }
        finally{
            rwlock.readLock().unlock();
        }
    }
}
public class readWriteLock {

    /*
        结果：
        3:准备写入值
        3:写操作完成
        0:准备写入值
        0:写操作完成
        4:准备写入值
        4:写操作完成
        1:准备写入值
        1:写操作完成
        2:准备写入值
        2:写操作完成
        0:开始读
        1:开始读
        2:开始读
        4:开始读
        3:开始读
        2:结束读，结果是2
        4:结束读，结果是4
        1:结束读，结果是1
        0:结束读，结果是0
        3:结束读，结果是3

    */

    public static void main(String[] args) throws InterruptedException {
        cache resource=new cache();
        //写锁5线程
        for(int i=0;i<5;i++) {
            final int value=i;
            new Thread(()->{
                try {
                    resource.put(String.valueOf(value),String.valueOf(value));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

        //让所有的写操作完成
        Thread.sleep(3000);

        //读锁5线程
        for(int i=0;i<5;i++)
        {
            final int value=i;
            new Thread(()->{
                resource.get(String.valueOf(value));
            },String.valueOf(i)).start();
        }
    }
}