读写锁ReentrantReadWriteLock的使用

读写锁的使用

读写锁是思想是将读锁和写锁分离，实现所谓线程之间读读共享，写写互斥这样的一个条件，即作用在资源访问频繁，但是更新次数较少的情况下。

JAVA中提供ReentrantReadWriteLock即为读写锁，ReentrantReadWriteLock中提供ReadLock(读锁，共享锁)，WirteLock(写锁，排他锁)。

以下为ReentrantReadWriteLock使用案例

package Lock;

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

/**
 * @author Dong.Chao
 * @Classname ReadWriteLock ， 读写锁验证
 * @Description
 * @Date 2021/3/22 14:33
 * @Version V1.0
 */
public class ReadWriteLockDemo {

    private static volatile HashMap<String,Object> hashMap = new HashMap<>();

    final static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public  static void put(String key,Object o){
        try {
            readWriteLock.writeLock().lock();
            System.out.println(key+"开始加入缓存");
            hashMap.put(key,o);
            System.out.println(key+"加入缓存完成");
        }finally {
            readWriteLock.writeLock().unlock();
        }


    }


    public static Object get(String key){
        Object o = null;
        try {
            readWriteLock.readLock().lock();
            System.out.println(key+"开始读取缓存");
            Thread.sleep(1000);
            o = hashMap.get(key);
            System.out.println(key+"读取缓存完成为"+o);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
           readWriteLock.readLock().unlock();
        }
        return o;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 4; i++) {
            final int index = i;
            new Thread(() -> {
                put(index+"",index+"");
            },"Thread"+index).start();
        }

        for (int i = 0; i < 4; i++) {
            final int index = i;
            new Thread(() -> {
                //System.out.println("读取缓存,key为:"+index+"value为:"+get(index+""));
                get(index+"");
            },"Thread"+index).start();
        }

    }

}

这里将读线程Sleep了4s ，可以看到，ReadLock是可以由多个线程持有该锁的。

需要注意一点:一般情况下独占锁的效率低来源于高并发下对临界区的激烈竞争导致线程上下文切换。因此当并发不是很高的情况下，读写锁由于需要额外维护读锁的状态，可能还不如独占锁的效率高。因此需要根据实际情况选择使用。