Java多线程之读写锁ReentrantReadWriteLock类使用

在JDK中提供了一种读写锁ReentrantReadWriteLock类，相比ReentrantLock类，使用前者可以加快运行效率。ReentrantLock类是具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()方法后面的任务，这样做虽然保证了实例变量的线程安全性，但效率却是非常低下的。所以在某些不需要操作实例变量的方法中，完全可以使用读写锁ReentrantReadWriteLock来提升该方法的代码运行速度。

读写锁简介

读写锁表示也有两个锁，一个是读操作相关的锁，也称为共享锁；另一个是写操作相关的锁，也叫排他锁。也就是多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。在没有线程Thread进行写入操作时，进行读取操作的多个Thread都可以获取读锁，而进行写入操作的Thread只有在获取写锁后才能进行写入操作。即多个Thread可以同时进行读取操作，但是同一时刻只允许一个Thread进行写入操作。

---

下面我们来看ReentrantReadWriteLock类的使用实例：

一、读读共享

创建一个读写服务类ReadWriteService.java，代码如下：

public class ReadWriteService {
	// 创建读写锁
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
	// 读方法
    public void read() {
        try {
            try {
                lock.readLock().lock();
                System.out.println("获取读锁" + Thread.currentThread().getName()
                        + "==" + System.currentTimeMillis());
                Thread.sleep(5000);
            } finally {
                lock.readLock().unlock();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

创建两个线程，调用读写服务。代码如下：

线程一

public class Thread1 extends Thread {
    private ReadWriteService readWriteService;

    public Thread1(ReadWriteService readWriteService){
        super();
        this.readWriteService = readWriteService;
    }

    @Override
    public void run() {
        readWriteService.read();
    }
}

线程二

public class Thread2 extends Thread{
    private ReadWriteService readWriteService;

    public Thread2(ReadWriteService readWriteService){
        super();
        this.readWriteService = readWriteService;
    }

    @Override
    public void run() {
        readWriteService.read();
    }
}

启动线程，代码如下：

public class Main {
        public static void main(String[] args) {
            ReadWriteService service = new ReadWriteService();
            Thread1 a = new Thread1(service);
            a.setName("A");
            Thread2 b = new Thread2(service);
            b.setName("B");
            a.start();
            b.start();
        }
}

输出如下：

从控制台中打印的时间来看，两个线程几乎同时进入lock()方法后面的代码。说明在此使用了lock.readLock()读锁的确可以提高程序运行效率，他允许多个线程同时执行lock()方法后面的代码。

二、写写互斥

改一下读写服务类ReadWriteService.java，代码如下：

public class ReadWriteService {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void write() {
        try {
            try {
                lock.writeLock().lock();
                System.out.println("获取写锁" + Thread.currentThread().getName()
                        + "==" + System.currentTimeMillis());
                Thread.sleep(5000);
            } finally {
                lock.writeLock().unlock();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

然后修改一下两个线程中调用ReadWriteService的方法，启动

从运行结果可以看到使用写锁代码lock.writeLock()的效果就是同一时间只允许一个线程执行lock()方法后面的代码。

三、读写互斥

修改ReadWriteService.java代码

public class ReadWriteService {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    public void read() {
        try {
            try {
                lock.readLock().lock();
                System.out.println("获取读锁" + Thread.currentThread().getName()
                        + "==" + System.currentTimeMillis());
                Thread.sleep(5000);
            } finally {
                lock.readLock().unlock();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void write() {
        try {
            try {
                lock.writeLock().lock();
                System.out.println("获取写锁" + Thread.currentThread().getName()
                        + "==" + System.currentTimeMillis());
                Thread.sleep(5000);
            } finally {
                lock.writeLock().unlock();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

两个线程类中线程一调用读方法，线程二调用写方法；
然后修改启动类：

public class Main {
        public static void main(String[] args) {
            ReadWriteService service = new ReadWriteService();
            Thread1 a = new Thread1(service);
            a.setName("A");
            a.start();
            Thread2 b = new Thread2(service);
            b.setName("B");
            b.start();
        }
 }

输出：

由此可以说明“读写”操作也是互斥的，而且下一个示例说明了“写读”操作也是互斥的。也就是说，只要出现“写操作”的过程，就会是互斥的。

四、写读互斥

ReadWriteService.java代码还是跟读写互的一样，只要修改启动类线程执行顺序；代码如下：

public class Main {
        public static void main(String[] args) {
            ReadWriteService service = new ReadWriteService();
            Thread2 b = new Thread2(service);
            b.setName("B");
            b.start();
            Thread1 a = new Thread1(service);
            a.setName("A");
            a.start();
        }
}

运行结果：

可以看到“写读”操作也是互斥的。

总结：
ReentrantReadWriteLock类是读写锁，他对于“读写”、“写读”和“写写”都是互斥的；而“读读”是异步的，非互斥的。也就是只要包含写操作，就是互斥的；但是对于读读就是共享的。即多个Thread可以同时进行读取操作，但是同一时刻只允许一个Thread进行写入操作。