ReadWriteLock读写锁

ReadWriteLock读写锁

一、前言

　　java.util.concurrent.locks.ReadWriteLock 接口维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有writer，读取锁可以由多个reader 线程同时保持。写入锁是独占的。

　　ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操作占多数的数据结构。

　　ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性可以完全不需要考虑加锁操作。

　　所有 ReadWriteLock 实现都必须保证 writeLock 操作的内存同步效果也要保持与相关 readLock 的联系。也就是说，成功获取读锁的线程会看到写入锁之前版本所做的所有更新。

　　与互斥锁相比，读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer 线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader 线程），读-写锁利用了这一点。从理论上讲，与互斥锁相比，使用读-写锁所允许的并发性增强将带来更大的性能提高。在实践中，只有在多处理器上并且只在访问模式适用于共享数据时，才能完全实现并发性增强。

　　与互斥锁相比，使用读-写锁能否提升性能则取决于读写操作期间读取数据相对于修改数据的频率，以及数据的争用——即在同一时间试图对该数据执行读取或写入操作的线程数。例如，某个最初用数据填充并且之后不经常对其进行修改的 collection，因为经常对其进行搜索（比如搜索某种目录），所以这样的 collection 是使用读-写锁的理想候选者。但是，如果数据更新变得频繁，数据在大部分时间都被独占锁，这时，就算存在并发性增强，也是微不足道的。更进一步地说，如果读取操作所用时间太短，则读-写锁实现（它本身就比互斥锁复杂）的开销将成为主要的执行成本，在许多读-写锁实现仍然通过一小段代码将所有线程序列化时更是如此。最终，只有通过分析和测量，才能确定应用程序是否适合使用读-写锁。

　　使用ReadWriteLock应该注意的问题

　　尽管读-写锁的基本操作是直截了当的，但实现仍然必须作出许多决策，这些决策可能会影响给定应用程序中读-写锁的效果。这些策略的例子包括：

　　在 writer 释放写入锁时，reader 和 writer 都处于等待状态，在这时要确定是授予读取锁还是授予写入锁。Writer 优先比较普遍，因为预期写入所需的时间较短并且不那么频繁。Reader 优先不太普遍，因为如果 reader 正如预期的那样频繁和持久，那么它将导致对于写入操作来说较长的时延。公平或者“按次序”实现也是有可能的。

　　在 reader 处于活动状态而 writer 处于等待状态时，确定是否向请求读取锁的 reader 授予读取锁。Reader 优先会无限期地延迟 writer，而 writer 优先会减少可能的并发。

　　确定是否重新进入锁：可以使用带有写入锁的线程重新获取它吗？可以在保持写入锁的同时获取读取锁吗？可以重新进入写入锁本身吗？可以将写入锁在不允许其他 writer 干涉的情况下降级为读取锁吗？可以优先于其他等待的 reader 或 writer 将读取锁升级为写入锁吗？

　　在实际的开发中，我们应该考虑所有这些情况。

二、唯一的实现类ReentrantReadWriteLock

　　两个构造方法

ReentrantReadWriteLock()
          使用默认（非公平）的排序属性创建一个新的 ReentrantReadWriteLock。

ReentrantReadWriteLock(boolean fair)
          使用给定的公平策略创建一个新的 ReentrantReadWriteLock。

　　  fair - 如果此锁应该使用公平排序策略，则该参数的值为 true

　　方法摘要

protected  Thread	getOwner()           返回当前拥有写入锁的线程，如果没有这样的线程，则返回 null。
protected  Collection<Thread>	getQueuedReaderThreads()           返回一个 collection，它包含可能正在等待获取读取锁的线程。
protected  Collection<Thread>	getQueuedThreads()           返回一个 collection，它包含可能正在等待获取读取或写入锁的线程。
protected  Collection<Thread>	getQueuedWriterThreads()           返回一个 collection，它包含可能正在等待获取写入锁的线程。
int	getQueueLength()           返回等待获取读取或写入锁的线程估计数目。
int	getReadHoldCount()           查询当前线程在此锁上保持的重入读取锁数量。
int	getReadLockCount()           查询为此锁保持的读取锁数量。
protected  Collection<Thread>	getWaitingThreads(Condition condition)           返回一个 collection，它包含可能正在等待与写入锁相关的给定条件的那些线程。
int	getWaitQueueLength(Condition condition)           返回正等待与写入锁相关的给定条件的线程估计数目。
int	getWriteHoldCount()           查询当前线程在此锁上保持的重入写入锁数量。
boolean	hasQueuedThread(Thread thread)           查询是否给定线程正在等待获取读取或写入锁。
boolean	hasQueuedThreads()           查询是否所有的线程正在等待获取读取或写入锁。
boolean	hasWaiters(Condition condition)           查询是否有些线程正在等待与写入锁有关的给定条件。
boolean	isFair()           如果此锁将公平性设置为 ture，则返回 true。
boolean	isWriteLocked()           查询是否某个线程保持了写入锁。
boolean	isWriteLockedByCurrentThread()           查询当前线程是否保持了写入锁。
ReentrantReadWriteLock.ReadLock	readLock()           返回用于读取操作的锁。
String	toString()           返回标识此锁及其锁状态的字符串。
ReentrantReadWriteLock.WriteLock	writeLock()           返回用于写入操作的锁。

三、示例代码

package me.concurrent.rwl;

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

/*
 * 1. ReadWriteLock : 读写锁
 * 
 * 写写/读写 需要“互斥”
 * 读读 不需要互斥
 * 
 */
public class TestReadWriteLock {

    public static void main(String[] args) {
    ReadWriteLockDemo rw = new ReadWriteLockDemo();

    new Thread(new Runnable() {

        @Override
        public void run() {
        rw.set((int) (Math.random() * 101));
        }
    }, "Write:").start();

    for (int i = 0; i < 100; i++) {
        new Thread(new Runnable() {

        @Override
        public void run() {
            rw.get();
        }
        }).start();
    }
    }

}

class ReadWriteLockDemo {

    private int number = 0;

    private ReadWriteLock lock = new ReentrantReadWriteLock();

    // 读
    public void get() {
    lock.readLock().lock(); // 上锁

    try {
        System.out.println(Thread.currentThread().getName() + " : " + number);
    } finally {
        lock.readLock().unlock(); // 释放锁
    }
    }

    // 写
    public void set(int number) {
    lock.writeLock().lock();

    try {
        System.out.println(Thread.currentThread().getName());
        this.number = number;
    } finally {
        lock.writeLock().unlock();
    }
    }
}

　　如上代码中创建了一个写线程和100个读线程

如果，您对我的这篇博文有什么疑问，欢迎评论区留言，大家互相讨论学习。
如果，您认为阅读这篇博客让您有些收获，不妨点击一下右下角的【推荐】。
如果，您希望更容易地发现我的新博客，不妨点击一下左下角的【关注我】。
如果，您对我的博文感兴趣，可以关注我的后续博客，我是【AlbertRui】。

转载请注明出处和链接地址，欢迎转载，谢谢！