ReentrantWriteLock

目录

特点：

支持锁降级

 使用ReentrantWriterReaderLock例子

读写锁实现缓存例子：

---

 

特点：

读读并发，读写，写写互斥；

可重入 :在写锁中可以放读锁,因为读锁是是并行的,提高效率

 读写分离:

我们知道，对于一个数据，不管是几个线程同时读都不会出现任何问题，但是写就不一样了，几个线程对同一个数据进行更改就可能会出现数据不一致的问题，因此想出了一个方法就是对数据加锁，这时候出现了一个问题：
线程写数据的时候加锁是为了确保数据的准确性，但是线程读数据的时候再加锁就会大大降低效率，这时候怎么办呢？那就对写数据和读数据分开，加上两把不同的锁，不仅保证了正确性，还能提高效率。
 

比如，你有多个线程在读取内容，另一个线程给他升级版本，这样对读取肯定不友好——>这就是读写锁的重入；（但是这套重入只针对于读的时候写）

如果是写的时候读那就没关系了（边更新边读取内容）——>也就是说我们可以在写锁释放前获得读锁；——>可以理解为降级

支持锁降级

降级为读锁的好处：可以让其他线程都读取缓存数据，不被其他线程写烦扰，然后写锁unlock防止其他线程干扰数据，造成读影响；——>因为读锁是可以并行的,所以降锁可以实现一起读取内容的功能;

案例：缓存

 首次没有数据的时候，可能发生多个线程查询数据但是没有缓存数据

缓存更新策略

提出问题：是先清缓存还是先更新数据库？

1.先清缓存时：

当B先清空缓存，进行更新，还没更新完A对数据库查询并缓存；当B更新完后，A读取的一直是原来的值而不是更新后的值，因为缓存在更新前就已经实现了；

2.先更新数据库再清缓存：

当B先对数据库进行更新时，缓存就算不一致也没关系，因为你其他线程进行数据库查询就会得到新值——>可以后面将缓存内容纠正过来；

 为了防止指令交错，出现指令重排现象：加锁

 使用ReentrantWriterReaderLock例子

package com.example.juc.ReentrentWriteLock.Redis;

import lombok.extern.slf4j.Slf4j;

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

/**
 * @author diao 2022/4/26
 */
@Slf4j(topic = "c.CacheTest")
public class CacheTest {
    public static void main(String[] args) throws InterruptedException {
        Cache myCache = new Cache();
        for (int i = 1;i<=5;i++){
            final int tmp = i;
            Thread t2=new Thread(()->{
                //写
                myCache.put(tmp+"", tmp+"");
            },"写"+tmp);
            t2.start();
            t2.join();
        }
        log.debug("开始读取资源");
        for (int i = 1;i<=5;i++){
            final int tmp = i;
           Thread t1=new Thread(()->{
                //读
                myCache.get(tmp+"");
            },"读"+tmp);
           t1.start();
        }
    }
}

@Slf4j(topic = "c.Cache")
class Cache{
    //1.共享资源
    Map<String,String> map=new HashMap<>();

    //2.读写锁
    private ReentrantReadWriteLock rw=new ReentrantReadWriteLock();

    //3.写操作
    public void put(String key,String value){
        rw.writeLock().lock();

        try {
            log.debug("{}\t正在写入...",Thread.currentThread().getName());
            map.put(key,value);
            log.debug("{}\t数据写入完成...",Thread.currentThread().getName());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
         rw.writeLock().unlock();
        }

    }

    //4.读操作
    public void get(String key){
       rw.readLock().lock();
        try {
            log.debug("{}\t正在读取...",Thread.currentThread().getName());
            String value = map.get(key);
            log.debug("{}\t数据读取完成，值为：{}",Thread.currentThread().getName(),value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rw.readLock().unlock();
        }

    }
}

读写锁实现缓存例子：

 进行双重检查——>对于数据：先在外面加写锁，如果缓存中没有value数据，就进行查询数据，然后再将数据放入缓存；

比如有多个线程，第一个线程拿到锁，进行判断发现缓存中没有数据，于是查询数据并放入缓存，释放锁后，其他线程进入发现有数据，直接返回即可；（map中的get数据相当于查询不需要保证原子性）