在并发编程中，当多个线程同时操作一个 变量时，容易出现线程安全的问题，我们可以使用各种锁来解决线程安全问题，比如：ConcurrentHashMap 在底层使用了synchronized 解决 HashMap()的线程安全问题, 我们这里希望使用 ReentrantReadWriteLock 来解决HashMap 的线程安全问题。

ConcurrentHashMap 使用 synchronized 解决线程安全，在putVal 方法中

ReentrantReadWriteLock 

构造方法

调用无参构造方法后，默认会调用非公平锁构造方法，并初始化 读锁和写锁。

private ReadWriteLock lock = new ReentrantReadWriteLock();

然后我们可以调用 读锁和写锁 分别对 hashmap 进行 写入和读取， 代码如下：

1、类中我们 定义了全局的 HashMap， 对它的操作是非线程安全的

2、初始化了ReentrantReadWriteLock，并调用了 readLock 和 writeLock 方法

3、在set 方法调用了 wlock.lock(), get 方法调用了 rlock.lock();

4、创建一个固定线程池，启动800个线程去并发操作，本例使用springboot 进行单元测试。

package com.yy.dd;

import org.junit.jupiter.api.Test;

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

public class RWLockTest {

    private ReadWriteLock lock = new ReentrantReadWriteLock();

    private Lock rlock = lock.readLock();

    private Lock wlock = lock.writeLock();

    private static Map<String, String> map = new HashMap<>();

    @Test
    public void rwtest() throws InterruptedException {
        ExecutorService exec = Executors.newFixedThreadPool(800);
        for (int i = 0; i < 800; i++) {
            exec.execute(new Runnable() {
                @Override
                public void run() {
                    setMap(String.valueOf(Thread.currentThread().getId()), Thread.currentThread().getName());
                }
            });
        }
        exec.shutdown();

        TimeUnit.SECONDS.sleep(2);
        System.out.println("map中元素总和：" + map.size());
        System.out.println("finished");
    }

    public void setMap(String key, String value) {
        wlock.lock();
        try {
            map.put(key, value);
        } finally {
            wlock.unlock();
        }
    }

    public String getMap(String key) {
        rlock.lock();
        try {
            return map.get(key);
        } finally {
            rlock.unlock();
        }
    }

    public void remove(String key) {
        wlock.lock();
        try {
            map.remove(key);
        } finally {
            wlock.unlock();
        }
    }
}

加锁后的操作结果，读写锁保证了线程的安全：

map中元素总和：800
finished

注释掉锁后，再来执行一次，没有锁的情况下，map总和只有793，出现了脏数据。

map中元素总和：793
finished