原 java ReentrantReadWriteLock 读写锁

版权声明：本文为博主原创文章，请尊重他人的劳动成果，转载请附上原文出处链接和本声明。
本文链接：https://www.91mszl.com/zhangwuji/article/details/1136

独占锁：

指该锁一次只能被一个线程所持有。ReentrantLock和synchronized都是独占锁。

共享锁：

指该锁可以被多个线程所持有。对ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁。读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

验证读写锁代码如下：

package com.mszl.thread;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 功能：验证ReentrantReadWriteLock是读写锁
 * 备注：更多资料请访问 http://www.91mszl.com
 * @author bobo teacher
 */
class Mycache{
	private volatile Map<String, Object> map=new HashMap<String, Object>();
	private ReentrantReadWriteLock rwl=new ReentrantReadWriteLock();
	
	
	public void putValue(String key, Object value){
		rwl.writeLock().lock();
		try {
			System.out.println("正在写入数据。。。" + Thread.currentThread().getName() + "\t" + key);
			Thread.sleep(1000);
			map.put(key, value);
			System.out.println("写入完成。。。" + Thread.currentThread().getName() + "\t" + key);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			rwl.writeLock().unlock();
		}
	}
	
	public void getValue(String key){
		rwl.readLock().lock();
		try {
			System.out.println("正在读取数据。。。" + Thread.currentThread().getName() + "\t" + key);
			Thread.sleep(3000);
			Object result=map.get(key);
			System.out.println("读取完成。。。" + Thread.currentThread().getName() + "\t" + result);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			rwl.readLock().unlock();
		}
	}
	
	
}

public class ReadWriteLockDemo {
	
	public static void main(String[] args) {
		Mycache mc=new Mycache();
		
		// 5个线程同时写入
		for (int i = 1; i <= 5; i++) {
			final int tmp=i;
			Thread t=new Thread(new Runnable() {
				@Override
				public void run() {
					mc.putValue(String.valueOf(tmp), "91mszl.com");
				}
			});
			t.start();
		}
		
		// 5个线程同时读取
		for (int i = 1; i <= 5; i++) {
			final int aa=i;
			Thread d=new Thread(new Runnable() {
				@Override
				public void run() {
					mc.getValue(String.valueOf(aa));
				}
			});
			d.start();
		}
	}
	

}

执行结果：

正在写入数据。。。Thread-0	1
写入完成。。。Thread-0	1
正在写入数据。。。Thread-2	3
写入完成。。。Thread-2	3
正在写入数据。。。Thread-4	5
写入完成。。。Thread-4	5
正在写入数据。。。Thread-1	2
写入完成。。。Thread-1	2
正在读取数据。。。Thread-6	2
正在读取数据。。。Thread-8	4
读取完成。。。Thread-8	null
读取完成。。。Thread-6	91mszl.com
正在写入数据。。。Thread-3	4
写入完成。。。Thread-3	4
正在读取数据。。。Thread-5	1
正在读取数据。。。Thread-9	5
正在读取数据。。。Thread-7	3
读取完成。。。Thread-5	91mszl.com
读取完成。。。Thread-7	91mszl.com
读取完成。。。Thread-9	91mszl.com

备注：我们可以看到写操作保证原子性+独占，整个过程必须是一个完整统一体，中间不允许被分割，被打断。