Java多线程编程-（5）使用ReentrantReadWriteLock实现并发

类ReentrantLock具有完全互斥排他的效果，即同一时间只能有一个线程在执行ReentrantLock.lock()之后的任务。

类似于我们集合中有同步类容器 和 并发类容器，HashTable（HashTable几乎可以等价于HashMap，并且是线程安全的）也是完全排他的，即使是读也只能同步执行，而ConcurrentHashMap就可以实现同一时刻多个线程之间并发。为了提高效率，ReentrantLock的升级版ReentrantReadWriteLock就可以实现效率的提升。

ReentrantReadWriteLock有两个锁：一个是与读相关的锁，称为“共享锁”；另一个是与写相关的锁，称为“排它锁”。也就是多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。

在没有线程进行写操作时，进行读操作的多个线程都可以获取到读锁，而写操作的线程只有获取写锁后才能进行写入操作。即：多个线程可以同时进行读操作，但是同一时刻只允许一个线程进行写操作。

ReentrantReadWriteLock锁的特性：

（1）读读共享； 
（2）写写互斥； 
（3）读写互斥； 
（4）写读互斥；

ReentrantReadWriteLock实例代码

（1）读读共享

package com.reentrantreadwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author wanjiadong
 * @description
 * @date Create in 10:49 2019/1/7
 */
public class ReentrantReadWriteLockDemo {

    private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        ReentrantReadWriteLockDemo demo = new ReentrantReadWriteLockDemo();

        new Thread(() -> demo.read(), "thread1").start();
        new Thread(() -> demo.read(), "thread2").start();
    }

    private void read() {
        reentrantReadWriteLock.readLock().lock();
        try {
            System.out.println("thread name = " + Thread.currentThread().getName() + ",current time : " + System.currentTimeMillis());
            Thread.sleep(5000L);
            System.out.println("thread name = " + Thread.currentThread().getName() + ",end time : " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }

    }
}

 执行结果：

可以看出两个线程之间，获取锁的时间几乎同时，说明lock.readLock().lock(); 允许多个线程同时执行lock（）方法后面的代码。

（2）写写互斥

package com.reentrantreadwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author wanjiadong
 * @description
 * @date Create in 10:49 2019/1/7
 */
public class ReentrantReadWriteLockDemo {

    private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        ReentrantReadWriteLockDemo demo = new ReentrantReadWriteLockDemo();

        new Thread(() -> demo.write(), "thread1").start();
        new Thread(() -> demo.write(), "thread2").start();
    }

    private void read() {
        reentrantReadWriteLock.readLock().lock();
        try {
            System.out.println("thread name = " + Thread.currentThread().getName() + ",current time : " + System.currentTimeMillis());
            Thread.sleep(5000L);
            System.out.println("thread name = " + Thread.currentThread().getName() + ",end time : " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }
    }

    private void write() {
        reentrantReadWriteLock.writeLock().lock();
        try {
            System.out.println("thread name = " + Thread.currentThread().getName() + ", 获取写锁time : " + System.currentTimeMillis());
            Thread.sleep(5000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("thread name = " + Thread.currentThread().getName() + ", 释放写锁time : " + System.currentTimeMillis());
            reentrantReadWriteLock.writeLock().unlock();
        }
    }
}

 执行结果：

可以看出执行结果大致差了5秒的时间，可以说明多个写线程是互斥的。 

 （3）读写互斥或写读互斥

package com.reentrantreadwritelock;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author wanjiadong
 * @description
 * @date Create in 10:49 2019/1/7
 */
public class ReentrantReadWriteLockDemo {

    private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        ReentrantReadWriteLockDemo demo = new ReentrantReadWriteLockDemo();

        new Thread(() -> demo.read(), "thread1").start();
        new Thread(() -> demo.write(), "thread2").start();
    }

    private void read() {
        reentrantReadWriteLock.readLock().lock();
        try {
            System.out.println("thread name = " + Thread.currentThread().getName() + ",current time : " + System.currentTimeMillis());
            Thread.sleep(5000L);
            System.out.println("thread name = " + Thread.currentThread().getName() + ",end time : " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantReadWriteLock.readLock().unlock();
        }
    }

    private void write() {
        reentrantReadWriteLock.writeLock().lock();
        try {
            System.out.println("thread name = " + Thread.currentThread().getName() + ", 获取写锁time : " + System.currentTimeMillis());
            Thread.sleep(5000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("thread name = " + Thread.currentThread().getName() + ", 释放写锁time : " + System.currentTimeMillis());
            reentrantReadWriteLock.writeLock().unlock();
        }
    }
}

执行结果：

可以看出执行结果大致差了5秒的时间，可以说明读写线程是互斥的。