读写锁ReentrantReadWriteLock学习

在没有写操作的时候，两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写（译者注：也就是说：读-读能共存，读-写不能共存，写-写不能共存）。这就需要一个读/写锁来解决这个问题。Java5在java.util.concurrent包中已经包含了读写锁。

还有一点，读写锁的运用，不一定是写一个才读一个，可能是在写的过程中，穿插几个读操作，读写锁保证的是在写的过程中，一定不会被读的线程所干扰，类似于保证原子性。

看下测试代码：

package thread.lock;

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



class Cache {

	private volatile static Map<String,Object> map = new HashMap<String,Object>();
	static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
	static Lock r = rwl.readLock();
	static Lock w = rwl.writeLock();
	/**
	 * 写操作
	 */
	public static  void input(String key,Object obj){
		w.lock();
		try {
			System.out.println("开始进行写操作,key:"+key+",value:"+obj);
			Thread.sleep(100);
			map.put(key, obj);
			System.out.println("结束进行写操作,key:"+key+",value:"+obj);
			System.out.println();
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			w.unlock();
		}
		
	}
	/*
	 * 读操作
	 */
	public static void output(String key){
		r.lock();
		try {
			System.out.println("开始进行读操作,key:"+key);
			Thread.sleep(100);
			Object object = map.get(key);
			System.out.println("结束进行读操作,key:"+key+",得到的value:"+object);
			System.out.println();
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			r.unlock();
		}
		
	}
}
public class Test2 {
	
	public static void main(String[] args) {
		new Thread(new Runnable() {
			public void run() {
				for(int i=0;i<10;i++){
					Cache.input(i+"", i+"");
				}
			}
		}).start();
		new Thread(new Runnable() {
			public void run() {
				for(int i=0;i<10;i++){
					Cache.output(i+"");
				}
			}
		}).start();
	}

}