ReentrantReadWriteLock理解与实例

Lock比传统线程模型中的synchronized方式更加面向对象，与生活中的锁类似，锁本身也应该是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须用同一个Lock对象。

　　读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上写锁！

ReentrantLock 实现了标准的互斥操作，也就是一次只能有一个线程持有锁，也即所谓独占锁的概念。我们也一直在强调这个特点。显然这个特点在一定程度上面减低了吞吐量，实际上独占锁是一种保守的锁策略，在这种情况下任何“读/读”，“写/读”，“写 /写”操作都不能同时发生。

锁是有一定的开销的，当并发比较大的时候，锁的开销就比较可观了。所以如果可能的话就尽量少用锁，如果非要用锁的话就尝试看能否能实现读写分离，将其改造为读写锁。

ReentrantReadWriteLock实现了ReadWriteLock接口，并没有实现Lock接口，是其内部类ReadLock和WriteLock实现了Lock的接口

对ReentrantReadWriteLock这个类，具体的可以参考前面的两篇文章：

深入浅出Java并发包—读写锁ReentrantReadWriteLock原理分析(一)

深入浅出Java并发包—读写锁ReentrantReadWriteLock原理分析(二)

那么我们要怎么去写一个读写锁的实例？

1、构造多线程，包括多个线程同时去读取数据和写数据、

2、锁是面向对象的，所以需要自定义一个对象，作为读写载体，比如get和set就是读和写操作

3、为该对象添加ReentrantReadWriteLock逻辑实现代码

package com.philos.thread;

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

public class ReadWriteLockTest {

	public static void main(String[] args) {
		final ReadWriteObject object = new ReadWriteObject();
		for (int i = 0; i < 5; i++) {
			new Thread(){
				public void run() {
					while (true) {
						object.read();
					}
				};
			}.start();
			for (int j = 0; j < 5; j++) {
				new Thread(){
					public void run() {
						while (true) {
							object.write(new Random().nextInt(10000));
						}
					};
				}.start();
		}
	}

		
}

}

class ReadWriteObject {
	//需要有一个可以读写的数据对象,就用Object
	Object data = null;//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
	private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
	
	//读取数据接口
	public void read(){
		rwl.readLock().lock();//上读锁，其他线程只能读不能写 
		System.out.println(Thread.currentThread().getName() + "准备开始读取数据!"); 
		try { 
			//模拟读取
			Thread.sleep((long)(Math.random()*1000)); 
			} catch (InterruptedException e) { 
				e.printStackTrace(); 
			} 
		System.out.println(Thread.currentThread().getName() + "读取完毕，data :" + data); 
		rwl.readLock().unlock(); //释放读锁，最好放在finnaly里面
	}
	
	public void write(Object data){
		rwl.writeLock().lock();//上写锁，不允许其他线程读也不允许写 
		System.out.println(Thread.currentThread().getName() + " 准备写数据!");
		//模拟写数据
		try {
			Thread.sleep((long)(Math.random()*1000)); 
		} catch (InterruptedException e) { 
			e.printStackTrace(); 
		}
		this.data = data; 
		System.out.println(Thread.currentThread().getName() + " have write data: " + data);
		rwl.writeLock().unlock();//释放写锁 
		}
	}

运行结果：

Thread-0准备开始读取数据!
Thread-6准备开始读取数据!
Thread-0读取完毕，data :null
Thread-6读取完毕，data :null
Thread-3 准备写数据!
Thread-3 have write data: 8595
Thread-4 准备写数据!
Thread-4 have write data: 5398
Thread-2 准备写数据!
Thread-2 have write data: 1939
Thread-2 准备写数据!
Thread-2 have write data: 1541
Thread-2 准备写数据!
Thread-2 have write data: 4603
Thread-8 准备写数据!
Thread-8 have write data: 5696
Thread-1 准备写数据!
Thread-1 have write data: 447
Thread-5 准备写数据!
Thread-5 have write data: 9707
Thread-7 准备写数据!
Thread-7 have write data: 9322
Thread-9 准备写数据!
Thread-9 have write data: 379