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是独占的。

你可能感兴趣的:(ReentrantReadWriteLock小结)