读写锁

简介

• 本质是提高线程并发的手段，java里面通过ReentrantReadWriteLock实现
• 可以实现对同一个资源类的读写分离

互斥条件

1. 读 - 读 不互斥
2. 读 - 写 互斥
3. 写 - 写 互斥

代码验证

class MyCache{ //资源类

    private volatile Map<String,Object> map = new HashMap<>();
    //private Lock lock = new ReentrantLock();
    ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();

    public void put(String key,Object value) { //写，原子，独占

         rwlock.writeLock().lock();
             try {
                 System.out.println("线程正在写入: \t");
                 //暂停一会儿线程
                 try {
                     TimeUnit.SECONDS.sleep(2);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }

                 map.put(key,value);
                 System.out.println("写入完成: \t");
             } finally {
                 rwlock.writeLock().unlock();
             }

    }

    public void get(String key){
         rwlock.readLock().lock();
             try {
                 System.out.println("正在读取..." + key);
                 try {
                     TimeUnit.SECONDS.sleep(3);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 Object o = map.get(key);
                 System.out.println("读取完成: "+o);
             } finally {
                 rwlock.readLock().unlock();
             }
    }

    public void clearMap(){
        map.clear();
    }

}


public class ReadWriteLock {

    public static void main(String[] args) {

        MyCache myCache = new MyCache();

        for (int i = 0; i < 5; i++) {
            final int tmp = i;
            new Thread(() -> {
                myCache.put(tmp+"",tmp+"");
            },String.valueOf(i)).start();
        }

        for (int i = 0; i < 5; i++) {
            final int tmp = i;
            new Thread(() -> {
                myCache.get(String.valueOf(tmp));
            }).start();
        }
    }
}