JUC- 读写锁

读写锁

ReadWriteLockDemo、ReadWriteDemo

1 读写锁介绍

场景:

对共享资源有读和写的操作，且写操作没有读操作那么频繁。
在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源;但是，如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了。
针对这种场景，JAVA 的并发包提供了读写锁 ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁;一个是写相关的锁，称为排他锁。

线程进入读锁的前提条件

• 没有其他线程的写锁
• 没有写请求, 或者有写请求，但调用线程和持有锁的线程是同一个(可重入锁)。

线程进入写锁的前提条件

• 没有其他线程的读锁
• 没有其他线程的写锁
• 而读写锁有以下三个重要的特性:
  • (1) 公平选择性:支持非公平(默认)和公平的锁获取方式，吞吐量还是非公平优于公平。
  • (2) 重进入:读锁和写锁都支持线程重进入。
  • (3) 锁降级:遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为读锁。

2 ReentrantReadWriteLock

ReentrantReadWriteLock 类的整体结构

public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {
    /** 读锁 */
    private final ReentrantReadWriteLock.ReadLock readerLock;
    /** 写锁 */
    private final ReentrantReadWriteLock.WriteLock writerLock;
    final Sync sync;
    /** 使用默认(非公平)的排序属性创建一个新的 ReentrantReadWriteLock */
    public ReentrantReadWriteLock() {
        this(false);
    }
    /** 使用给定的公平策略创建一个新的 ReentrantReadWriteLock */
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }
    /** 返回用于写入操作的锁 */
    public ReentrantReadWriteLock.WriteLock writeLock() {
        return writerLock;
    }
    /** 返回用于读取操作的锁 */
    public ReentrantReadWriteLock.ReadLock readLock() {
        return readerLock;
    }
    abstract static class Sync extends AbstractQueuedSynchronizer {}
    static final class NonfairSync extends Sync {}
    static final class FairSync extends Sync {}
    public static class ReadLock implements Lock, java.io.Serializable {}
    public static class WriteLock implements Lock, java.io.Serializable {}
}

可以看到，ReentrantReadWriteLock 实现了 ReadWriteLock 接口，ReadWriteLock 接口定义了获取读锁和写锁的规范，具体需要实现类去实现;同时其还实现了 Serializable 接口，表示可以进行序列化，在源代码中可以看到 ReentrantReadWriteLock 实现了自己的序列化逻辑。

3 入门案例

场景:
使用 ReentrantReadWriteLock 对一个 hashmap 进行读和写操作

3.1 实现案例

//资源类
class MyCache {
    //创建 map 集合
    private volatile Map<String,Object> map = new HashMap<>();
    //创建读写锁对象
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();
    //放数据
    public void put(String key,Object value) {
        //添加写锁
        rwLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+" "+key);
            //暂停一会
            TimeUnit.MICROSECONDS.sleep(300);
            //放数据
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+" "+key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放写锁
            rwLock.writeLock().unlock();
        }
    }

    //取数据
    public Object get(String key) {
        //添加读锁
        rwLock.readLock().lock();
        Object result = null;
        try {
            System.out.println(Thread.currentThread().getName()+" "+key);
            //暂停一会
            TimeUnit.MICROSECONDS.sleep(300);
            result = map.get(key);
            System.out.println(Thread.currentThread().getName()+" "+key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放读锁
            rwLock.readLock().unlock();
        }
        return result;
    }
}

4 小结(重要)

• 在线程持有读锁的情况下，该线程不能取得写锁
  (因为获取写锁的时候，如果发现当前的读锁被占用，就马上获取失败，不管读锁是不是被当前线程持有)。
• 在线程持有写锁的情况下，该线程可以继续获取读锁
  (获取读锁时如果发现写锁被占用，只有写锁没有被当前线程占用的情况才会获取失败)。

原因:
当线程获取读锁的时候，可能有其他线程同时也在持有读锁，因此不能把获取读锁的线程“升级”为写锁;而对于获得写锁的线程，它一定独占了读写锁，因此可以继续让它获取读锁，当它同时获取了写锁和读锁后，还可以先释放写锁继续持有读锁，这样一个写锁就“降级”为了读锁。

5 锁降级demo

package com.java.juc.readWrite;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @program: chejSta
 * @description: 锁降级
 * @author: chej
 * @create: 2021-10-15 12:01
 **/
public class ReadWriteDemo {
    public static void main(String[] args){
        //可重入读写锁对象
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        //读锁
        ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
        //写锁
        ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
        System.out.println("=========== 锁降级 ============");
        //锁降级 demo
        //获取写锁
        writeLock.lock();
        System.out.println("+++++ write ++++++");
        //获取读锁
        readLock.lock();
        System.out.println("----- read ---------");
        //释放写锁
        writeLock.unlock();
        //释放读锁
        readLock.unlock();

        System.out.println("=========== 读锁不能升级 ============");
        //读锁不能升级 demo
        readLock.lock();
        System.out.println("----- read2 ---------");

        //获取写锁
        writeLock.lock();
        System.out.println("+++++ write2 ++++++");

        //释放读锁
        readLock.unlock();
        //释放写锁
        writeLock.unlock();

    }
}