ReentrantReadWriteLock读写锁

ReentrantLock实现了标准的互斥锁：一次最多只有一个线程能够持有相同ReentrantLock。但是互斥通常做为保护数据一致性的很强的加锁约束，因此，过分的限制了并发性。互斥是保守的加锁策略，避免了

“写/写”和“写/读"的重读，但是同样避开了"读/读"的重叠。在很多情况下，数据结构是”频繁被读取“的——它们是可变的，有时候会被改变，但多数访问只进行读操作。此时，如果能够放宽，允许多个读者同时访问数据结构就

非常好了。只要每个线程保证能够读到最新的数据(线程的可见性)，并且在读者读取数据的时候没有其他线程修改数据，就不会发生问题。这就是读-写锁允许的情况：一个资源能够被多个读者访问，或者被一个写者访问，两者不能同时进行。

ReadWriteLock，暴露了2个Lock对象，一个用来读，另一个用来写。读取ReadWriteLock锁守护的数据，你必须首先获得读取的锁，当需要修改ReadWriteLock守护的数据，你必须首先获得写入锁。

ReadWriteLock源码接口如下：

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

读写锁实现的加锁策略允许多个同时存在的读者，但是只允许一个写者。与Lock一样，ReadWriteLock允许多种实现，造成性能，调度保证，获取优先，公平性，以及加锁语义等方面的不尽相同。

读写锁的设计是用来进行性能改进的，使得特定情况下能够有更好的并发性。时间实践中，当多处理器系统中，频繁的访问主要为读取数据结构的时候哦，读写锁能够改进性能；在其他情况下运行的情况比独占

的锁要稍微差一些，这归因于它更大的复杂性。使用它能否带来改进，最好通过对系统进行剖析来判断：好在ReadWriteLock使用Lock作为读写部分的锁，所以如果剖析得的结果发现读写锁没有能提高性能，把读写锁置换为独占锁是比较容易。

ReentrantReadWriteLock详解

下面我们用synchonized来进行读操作，对于读操作性能如何呢？

public class ReadWriteLockTest {
    private ReentrantReadWriteLock rw1 = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        final ReadWriteLockTest test = new ReadWriteLockTest();

        new Thread(){
            @Override
            public void run() {
                test.get(Thread.currentThread());
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                test.get(Thread.currentThread());
            }
        }.start();

    }

    public synchronized void get(Thread thread) {

        long start = System.currentTimeMillis();
        while (System.currentTimeMillis() - start <= 1){
            System.out.println(thread.getName() + "正在读操作");
        }
        System.out.println(thread.getName() + "读操作完成");

    }

}

执行结果:

Thread-0正在读操作
Thread-0正在读操作
Thread-0正在读操作
Thread-0读操作完成
Thread-1正在读操作
Thread-1正在读操作
Thread-1正在读操作
Thread-1正在读操作
Thread-1正在读操作
Thread-1读操作完成

可以看到要线程Thread0读操作完了，Thread1才能进行读操作。明显这样性能很慢。

现在我们用ReadWriteLock来进行读操作，看一下性能如何

基础代码:

public class ReadWriteLockTest {
		private ReentrantReadWriteLock rw1 = new ReentrantReadWriteLock();

    public  void getW(Thread thread) {
        try {
            rw1.writeLock().lock();
            long start = System.currentTimeMillis();
            while (System.currentTimeMillis() - start <= 10){
                System.out.println(thread.getName() + "正在写操作");
            }
            System.out.println(thread.getName() + "写操作完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rw1.writeLock().unlock();
        }

    }
        public  void getR(Thread thread) {
        try {
            rw1.readLock().lock();
            long start = System.currentTimeMillis();
            while (System.currentTimeMillis() - start <= 10){
                System.out.println(thread.getName() + "正在读操作");
            }
            System.out.println(thread.getName() + "读操作完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            rw1.readLock().unlock();
        }

    }
}	

并发读:

public static void main(String[] args) {
        final ReadWriteLockTest test = new ReadWriteLockTest();

        new Thread(){
            @Override
            public void run() {
                test.getR(Thread.currentThread());
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                test.getR(Thread.currentThread());
            }
        }.start();

    }

执行结果:

Thread-0正在读操作
Thread-0正在读操作
Thread-1正在读操作
Thread-1正在读操作
Thread-1正在读操作
Thread-0正在读操作
Thread-0正在读操作
Thread-1正在读操作
Thread-0读操作完成
Thread-1读操作完成

可以看到线程间是不用排队来读操作的。这样效率明显很高。

并发写:

public static void main(String[] args) {
        final ReadWriteLockTest test = new ReadWriteLockTest();

        new Thread(){
            @Override
            public void run() {
                test.getW(Thread.currentThread());
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                test.getW(Thread.currentThread());
            }
        }.start();

    }

执行结果:

Thread-0正在写操作
Thread-0正在写操作
Thread-0正在写操作
Thread-0正在写操作
Thread-0正在写操作
Thread-0正在写操作
Thread-0写操作完成
Thread-1正在写操作
Thread-1正在写操作
Thread-1正在写操作
Thread-1正在写操作
Thread-1正在写操作
Thread-1正在写操作
Thread-1正在写操作
Thread-1写操作完成

由此看出写写操作是互斥的

并发读写:

public static void main(String[] args) {
        final ReadWriteLockTest test = new ReadWriteLockTest();

        new Thread(){
            @Override
            public void run() {
                test.getR(Thread.currentThread());
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                test.getW(Thread.currentThread());
            }
        }.start();

    }

执行结果:

Thread-0正在读操作
Thread-0正在读操作
Thread-0正在读操作
Thread-0正在读操作
Thread-0正在读操作
Thread-0正在读操作
Thread-0读操作完成
Thread-1正在写操作
Thread-1正在写操作
Thread-1正在写操作
Thread-1正在写操作
Thread-1正在写操作
Thread-1正在写操作
Thread-1写操作完成

由此看出读写操作是互斥的

ReentrantReadWriteLock公平锁

ReentrantReadWriteLock为两个锁提供了可重入的加锁语义，它是继承了ReadWriteLock，扩展了ReadWriteLock。它与ReadWriteLock相同，ReentrantReadWriteLock能够被构造

为非公平锁(构造方法不设置参数，默认是非公平)，或者公平。在公平锁中，选择权交给等待时间最长的线程；如果锁由读者获得，而一个线程请求写入锁，那么不再允许读者获得读取锁，直到写者被受理，平且已经释放了写锁。

在非公平的锁中，线程允许访问的顺序是不定的。由写者降级为读者是允许的；从读者升级为写者是不允许的(尝试这样的行为会导致死锁)

　　当锁被持有的时间相对较长，并且大部分操作都不会改变锁守护的资源，那么读写锁能够改进并发性。ReadWriteMap使用了ReentrantReadWriteLock来包装Map,使得它能够在多线程间

被安全的共享，并仍然能够避免 "读-写" 或者 ”写-写“冲突。显示中ConcurrentHashMap并发容器的性能已经足够好了，所以你可以是使用他，而不必使用这个新的解决方案，如果你需要并发的部分

只有哈希Map，但是如果你需要为LinkedHashMap这种可替换元素Map提供更好的并发访问，那么这项技术是非常有用的。

用读写锁包装的Map如下图：

读写锁性能:

总结：

　　显式的Lock与内部锁相比提供了一些扩展的特性，包括处理不可用的锁时更好的灵活性，以及对队列行为更好的控制。但是ReentrantLock不能完全替代synchronized;只有当你需要synchronized没能提供的特性时才应该使用。

　　读-写锁允许多个读者并发访问被守护的对象，当访问多为读取数据结构的时候，它具有改进可伸缩性的潜力。

当时做记录的时候忘记记录原文链接了,作者看到之后可以私信我,我补上原文链接.