ReentrantReadWriteLock小结

           最近在看<<Java并发编程实践>>，有这样一个类：ReentrantReadWriteLock。在这里做一个小结：

 

线程获得写锁的前提条件：

 

    其他线程没有获得读锁：注意一定是其他线程!!!!!!!!!!!!!!!

public class ReadWriteLock{
	static ReentrantReadWriteLock myLock=new ReentrantReadWriteLock();
	static Lock readLock=myLock.readLock();
	static Lock writeLock=myLock.writeLock();
	
	static class MyThread extends Thread{
			public void run() {
				readLock.lock();
				//readLock.unlock();
			}
	}
	public static void main(String args[]){
		
		new MyThread().start();
		
		writeLock.lock();    //通过debug，发现程序阻塞在这里了，发生死锁。下面的"here"打印不出来。
		
		System.out.println("here");
	}
}
//运行结果：
//程序进入死锁，writeLock一直等待。
//只要将readLock.unlock()的注释解开，程序就跑通了。
//可见：要想获得写锁，别的线程必须没有获得读锁。

 

 

    其他线程没有获得写锁：

public class ReadWriteLock{
	static ReentrantReadWriteLock myLock=new ReentrantReadWriteLock();
	static Lock readLock=myLock.readLock();
	static Lock writeLock=myLock.writeLock();
	
	static class MyThread extends Thread{
			public void run() {
				writeLock.lock();
				//writeLock.unlock();
			}
	}
	public static void main(String args[]){
		
		new MyThread().start();
		
		writeLock.lock();    //通过debug，发现程序阻塞在这里了，发生死锁。下面的"here"打印不出来。
		
		System.out.println("here");
	}
}
//运行结果：
//效果同上，发生死锁.若解开writeLock.unlock()的注释则程序正常，成功输出here

 

 

线程进入读锁的前提条件：

 

    其他线程没有获得写锁：

 

public class ReadWriteLock{
	static ReentrantReadWriteLock myLock=new ReentrantReadWriteLock();
	static Lock readLock=myLock.readLock();
	static Lock writeLock=myLock.writeLock();
	
	static class MyThread extends Thread{
			public void run() {
				writeLock.lock();
				//writeLock.unlock();
			}
	}
	public static void main(String args[]){
		
		new MyThread().start();
		
		readLock.lock();    //通过debug，发现程序阻塞在这里了，发生死锁。下面的"here"打印不出来。
		
		System.out.println("here");
	}
}
//结果同上，获得读锁的前提是没有别的线程获得写锁

 

 

 

    没有写请求或者有写请求，但调用线程和持有锁的线程是同一个：

这一条完全不明白是什么意思。

 

 *******************************************************************************

      还有一个特性：一个线程可以先获得写锁，再获得读锁，比如这样：

 

public class ReadWriteLock{
	static ReentrantReadWriteLock myLock=new ReentrantReadWriteLock();
	static Lock readLock=myLock.readLock();
	static Lock writeLock=myLock.writeLock();
	public static void main(String args[]){
		writeLock.lock();
		readLock.lock();
		System.out.println("here");
	}
}
//运行结果：程序正常
here

 

 

    但是：一个线程不能先获得读锁再获得写锁，像这样：

 

public class ReadWriteLock{
	static ReentrantReadWriteLock myLock=new ReentrantReadWriteLock();
	static Lock readLock=myLock.readLock();
	static Lock writeLock=myLock.writeLock();
	public static void main(String args[]){
		readLock.lock();
		writeLock.lock();
		
		System.out.println("here");
	}
}
//运行结果：
//程序进入死循环

   

     因为一个线程可以先获得写锁，再获得读锁。所以：可以实现降级锁，即：      从写入锁降级为读取锁，其实现方式是：先获取写入锁，然后获取读取锁，最后释放写入锁。像这样：

public class ReadWriteLock{
	static ReentrantReadWriteLock myLock=new ReentrantReadWriteLock();
	static Lock readLock=myLock.readLock();
	static Lock writeLock=myLock.writeLock();
	public static void main(String args[]){
		writeLock.lock();
		readLock.lock();
		writeLock.unlock();
		
		System.out.println("here");
	}
}
//运行结果：
here

 

但是，从读取锁升级到写入锁是不可能的。

 

     最后一点：ReadLock可以被多个线程持有并且在作用时排斥任何的WriteLock，而WriteLock则是完全的互斥。这一特性最为重要，因为对于高读取频率而相对较低写入的数据结构，使用此类锁同步机制则可以提高并发量。 

下面根据一个网上的例子说明这一点：

public class ReentrantReadWriteLockSample {  
	  
    public static void main(String[] args) {  
        testReadLock();  
//      testWriteLock();  
    }  
      
    public static void testReadLock() {  
       final ReadWriteLockSampleSupport support = new ReadWriteLockSampleSupport();  
          
        Runnable runnable = new Runnable() {  
            public void run() {  
                support.get("test");  
            }  
        };  
          
        new Thread(runnable).start();  
        new Thread(runnable).start();  
          
        new Thread(new Runnable() {  
            public void run() {  
                support.put("test", "test");  
            }  
        }).start();  
    }  
      
    public static void testWriteLock() {  
       final ReadWriteLockSampleSupport support = new ReadWriteLockSampleSupport();  
          
        new Thread(new Runnable() {  
            public void run() {  
                support.put("key1", "value1");  
            }  
        }).start();  
          
        new Thread(new Runnable() {  
            public void run() {  
                support.put("key2", "value2");  
            }  
        }).start();  
          
        new Thread(new Runnable() {  
            public void run() {  
                support.get("key1");  
            }  
        }).start();  
    }  
}  
  
class ReadWriteLockSampleSupport {  
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();  
    private final Lock readLock = lock.readLock();  
    private final Lock writeLock = lock.writeLock();  
      
    private volatile  boolean completed= true; 
    private Map<String,String> cache = new HashMap<String,String>(32);  
    public String get(String key) {  
        readLock.lock();  
        System.out.println(Thread.currentThread().getName() + " read.");  
        startTheCountdown();  //等待5s
        try{  
            return cache.get(key);  
        }  
        finally{  
            readLock.unlock();  
        }  
    }  
      
    public String put(String key, String value) {  
        writeLock.lock();  
        System.out.println(Thread.currentThread().getName() + " write.");  
        startTheCountdown();  
        try{  
            return cache.put(key, value);  
        }  
        finally {  
            writeLock.unlock();  
        }  
    }  
      
    /** 
     * A simple countdown,it will stop after about 5s.  
     */  
    public void startTheCountdown() {  
        long currentTime = System.currentTimeMillis();  
        for(;;) { 
            long diff = System.currentTimeMillis() - currentTime;  
            if(diff > 5000) {  
                break;  
            }  
        }  
    }  
} 
// testReadLock();  和 testWriteLock();  分开运行

      ReentrantReadWriteLockSample中的两个静态测试方法则分别测试了ReadLock和WriteLock的排斥性。 testReadLock()中，开启三个线程，前两者试图获取ReadLock而后者去获取WriteLock。执行结果可以看 到：ReadWriteLockSampleSupport的get()方法中的打印结果在前两个线程中几乎同时显示，而put()中的打印结果则要等上 近5s。这就说明了，ReadLock可以多线程持有并且排斥WriteLock的持有线程。testWriteLock()中，也开启三个线程。前两个 是去获取WriteLock，最后一个获取ReadLock。执行的结果是三个打印结果都有近5s的间隔时间，这说明了WriteLock是独占的。