【高并发系列】12、读写锁 ReadWriteLock

java.util.concurrent.locks.ReadWriteLock是JDK5提供的读写分离锁；

• 读-读不互斥：读读之间不阻塞；
• 读-写互斥：读阻塞写，写阻塞读；
• 写-写互斥：写写阻塞；

在系统中，如果读操作次数远远大于写操作次数，则读写锁可以发挥最大的功效，提升系统的性能；

public class ReadWriteLockDemo {
	private static Lock lock = new ReentrantLock();
	private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
	private static Lock readLock = readWriteLock.readLock();
	private static Lock writeLock = readWriteLock.writeLock();
	private int value;
	public Object handleRead(Lock lock) throws InterruptedException {
		try {
			// 模拟读操作
			lock.lock();
			// 读操作耗时越多，读写锁优势越明显
			TimeUnit.SECONDS.sleep(1);
			return value;
		} finally {
			lock.unlock();
		}
	}
	public void handleWrite(Lock lock, int index) throws InterruptedException {
		try {
			// 模拟写操作
			lock.lock();
			TimeUnit.SECONDS.sleep(1);
			value = index;
		} finally {
			lock.unlock();
		}
	}
	public static void main(String[] args) {
		final ReadWriteLockDemo rwld = new ReadWriteLockDemo();
		Runnable readRunnable = new Runnable() {
			@Override
			public void run() {
				try {
					rwld.handleRead(readLock);
					// rwld.handleRead(lock);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}

			}
		};
		Runnable writeRunnable = new Runnable() {
			@Override
			public void run() {
				try {
					rwld.handleWrite(writeLock, new Random().nextInt());
					// rwld.handleWrite(lock, new Random().nextInt());
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		};
		for (int i = 0; i < 10; i++) {
			new Thread(readRunnable).start();
		}
		for (int i = 0; i < 10; i++) {
			new Thread(writeRunnable).start();
		}
	}
}

代码中使用休眠1秒模拟读写操作，如果使用读写锁，读读不阻塞，一共耗时10秒左右；如果使用普通的重入锁，读读也阻塞，一共耗时20秒左右；