JUC读写锁ReadWriteLock

1.概述

在一些业务场景中，如果大部分是读数据，写数据的很少，此时如果使用独占锁(synchronized，Lock)会导致效率低下，因此JUC提供了读写锁java.util.concurrent.locks.ReadWriteLock来解决这个问题

2.ReadWriteLock

读写锁允许同一时刻多个读线程同时访问，但是在写线程访问时，所有其他写线程和读线程都不可访问

特点：

• 写写不可并发
• 读写不可并发
• 读读允许并发

例子：

package example.juc2.test;

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

/**
 * 读写锁
 */
public class TestReadWriteLock {
    
    public static class MyCache {
        private volatile Map<String, String> map = new HashMap<>();
        private ReadWriteLock lock = new ReentrantReadWriteLock();
        
        public void write(String key, String valle) {
            lock.writeLock().lock();
            try {
                System.out.println(Thread.currentThread().getName() + "准备写入数据");
                TimeUnit.SECONDS.sleep(2);
                map.put(key, valle);
                System.out.println(Thread.currentThread().getName() + "写入数据完成");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.writeLock().unlock();
            }
        }
        
        public void read(String key) {
            lock.readLock().lock();
            try {
                System.out.println(Thread.currentThread().getName() + "准备读取数据");
                TimeUnit.SECONDS.sleep(2);
                String s = map.get(key);
                System.out.println(Thread.currentThread().getName() + " 读取数据 " + s);
            } catch (Exception e) {
                
            } finally {
                lock.readLock().unlock();
            }
        }
    }
    
    
    
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.write(finalI +"", finalI+"");
            }).start();
        }

        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.read(finalI +"");
            }).start();
        }
    }
}