读写锁ReentrantReadWriteLock

实例：

public class ReentrantReadWriteLockTest {
	private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
	//private static ReentrantLock lock = new ReentrantLock();
	private static ReadLock readLock = lock.readLock();
	private static WriteLock writeLock = lock.writeLock();
	private static Map<String,String> map = new HashMap<String,String>();

	//减数门栓，减为零后就不计算了
	private static CountDownLatch latch = new CountDownLatch(102);

	//周期循环的屏障。加到102后，从0开始计算
	private static CyclicBarrier barrier = new CyclicBarrier(102);
	
	
	public static void main(String[] args) throws InterruptedException{
		
		long beginTime = System.currentTimeMillis();
		
		
		for(int i = 0 ; i < 100 ; i++){
			new Thread(new ReadThread()).start();
		}
		for(int i = 0 ; i < 2 ; i++){
			new Thread(new WriteThread()).start();
		}
		latch.await();
		long endTime = System.currentTimeMillis();
		
		System.out.println("一共使用了" + (endTime-beginTime) + "ms");
		
	}

	static class WriteThread implements Runnable{
		public void run(){
			try {
				//相当于把所用读写线程放到同一水平线上在开始真正的计算
				barrier.await();
			}
			catch (Exception e) {
				e.printStackTrace();
			}

			try {
				//加在对象上的锁
				writeLock.lock();
				//lock.lock();
				map.put("1", "2");
				Thread.sleep(100);			}
			catch (Exception e) {
				e.printStackTrace();
			}
			finally{
				writeLock.unlock();

				//lock.unlock();
			}
			//latch把计数加一
			latch.countDown();


		}
	}
	
	
	
	
	static class ReadThread implements Runnable{
		public void run(){
			try {
				//相当于把所用读写线程放到同一水平线上在开始真正的计算
				barrier.await();
			}
			catch (Exception e) {
				e.printStackTrace();
			}

			try {
				//加在ReentrantReadWriteLockTest对象上的锁
				readLock.lock();
				//lock.lock();
				//System.out.println(this.toString());
				map.get("1");
				Thread.sleep(100);			}
			catch (Exception e) {
				e.printStackTrace();
			}
			finally{
				readLock.unlock();
				//lock.unlock();

			}
			latch.countDown();


		}
	}
}

注意：

1）读锁和写锁就是一个锁的不同视图，所以他和ReentrantLock类似都有可重入的语义。

2）同一个线程实现获得读锁的时候，再次想获取写锁的话，就会产生死锁，那么叫做不可升级。

3）同一个线程实现获得写锁的时候，可以再次获取读锁的话（lock.lock)，不会产生死锁，但是在最后写锁的释放就会把当前锁降级为读锁。

4）在读多写少的情况下，性能回避ReentrantLock这样的硬性加锁性能有很大的提升，不然的话性能就会低，因为读写锁的实现更为复杂。