ReadWriteLock读写锁

现实中有这样一种场景：对共享资源有读和写的操作，且写操作没有读操作那么频繁。在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源；但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了。

针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁

1. 线程进入读锁的前提条件： • 没有其他线程的写锁 • 没有写请求, 或者有写请求，但调用线程和持有锁的线程是同一个(可重入锁)。
2. 线程进入写锁的前提条件： • 没有其他线程的读锁 • 没有其他线程的写锁

而读写锁有以下三个重要的特性：

（1）公平选择性：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平。

（2）重进入：读锁和写锁都支持线程重进入。

（3）锁降级：遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为读锁。

ReentrantReadWriteLock

ReentrantReadWriteLock 类的整体结构

public class ReentrantReadWriteLock
        implements ReadWriteLock, java.io.Serializable {
    private static final long serialVersionUID = -6992448646407690164L;
    /** 读锁 */
    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; }

            ...
}

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

案例

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

package com.dongguo.readwrite;

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;

/**
 * @author Dongguo
 * @date 2021/8/24 0024-19:44
 * @description: ReadWriteLock
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        //创建线程放数据
        for (int i = 0; i  {
                myCache.put(num + "", num + "");
            }, "Thread"+i).start();
        }
        //创建线程取数据
        for (int i = 0; i  {
                myCache.get(num + "");
            }, "Thread"+(i + 5)).start();
        }
    }

    //资源类
    static class MyCache {
        //创建map集合
        private volatile Map 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;
        }
    }
}

运行结果：
Thread0写入：0
Thread0写完0
Thread1写入：1
Thread1写完1
Thread2写入：2
Thread2写完2
Thread3写入：3
Thread3写完3
Thread4写入：4
Thread4写完4
Thread5取出：0
Thread6取出：1
Thread7取出：2
Thread9取出：4
Thread8取出：3
Thread6取完1
Thread9取完4
Thread7取完2
Thread5取完0
Thread8取完3

读锁是共享锁， 写锁时独占锁

读写锁的演变

读写锁的降级

写锁降级为读锁过程

``

package com.dongguo.readwrite;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author Dongguo
 * @date 2021/8/24 0024-20:10
 * @description:演示读写锁降级
 */
public class Demo1 {
    public static void main(String[] args) {
        //可重入读写锁对象
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        //读锁
        ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
        //写锁
        ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
        //获取写锁
        writeLock.lock();
        System.out.println("我是写锁");
        //获取读锁
        readLock.lock();
        System.out.println("我是读锁");
        //释放写锁
        writeLock.unlock();
        //释放读锁
        readLock.unlock();
    }
}
运行结果：
我是写锁
我是读锁

在写的过程成也可以读

那么先读在写会怎么样呢？

``

package com.dongguo.readwrite;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author Dongguo
 * @date 2021/8/24 0024-20:10
 * @description:演示读写锁降级
 */
public class Demo1 {
    public static void main(String[] args) {
        //可重入读写锁对象
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        //读锁
        ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
        //写锁
        ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
        //获取读锁
        readLock.lock();
        System.out.println("我是读锁");
        //获取写锁
        writeLock.lock();
        System.out.println("我是写锁");
       
        //释放写锁
        writeLock.unlock();
        //释放读锁
        readLock.unlock();
    }
}

结果表示执行写操作的时候是不能进行写操作的

总结

在线程持有读锁的情况下，该线程不能取得写锁(因为获取写锁的时候，如果发现当前的读锁被占用，就马上获取失败，不管读锁是不是被当前线程持有)。 在线程持有写锁的情况下，该线程可以继续获取读锁（获取读锁时如果发现写锁被占用，只有写锁没有被当前线程占用的情况才会获取失败）。 原因: 当线程获取读锁的时候，可能有其他线程同时也在持有读锁，因此不能把获取读锁的线程“升级”为写锁；而对于获得写锁的线程，它一定独占了读写锁，因此可以继续让它获取读锁，当它同时获取了写锁和读锁后，还可以先释放写锁继续持有读锁，这样一个写锁就“降级”为了读锁。