读写锁的使用

转自：http://www.blogjava.net/junglesong/archive/2008/02/22/181400.html

读写锁的使用

本文内容

何时该使用读写锁.
读写锁的写法.
理解读写锁和线程互斥的区别。

复习-同步化的概念

当一个方法或代码块被声明成synchronized，要执行此代码必须先取得一个对象实例或this的锁定，这个锁定要在synchronized修饰的方法或代码块执行完后才能释放掉（无论这段代码是怎样返回的，是正常运行还是异常运行）。每个对象只有一个锁定，如果有两个不同的线程试图同时调用同一对象的同步方法，最终只会有一个能运行此方法，另外一个要等待第一个线程释放掉锁定后才能运行此方法。

读写锁应用的场合

我们有时会遇到对同一个内存区域如数组或者链表进行多线程读写的情况,一般来说有以下几种处理方式: 1.不加任何限制,多见于读取写入都很快的情况,但有时也会出现问题. 2.对读写函数都加以同步互斥,这下问题是没了,但效率也下去了,比如说两个读取线程不是非要排队进入不可. 3.使用读写锁,安全和效率都得到了解决,特别合适读线程多于写线程的情况.也就是下面将要展现的模式.

读写锁的意图

读写锁的本意是分别对读写状态进行互斥区分,有互斥时才加锁,否则放行.互斥的情况有: 1.读写互斥. 2.写写互斥. 不互斥的情况是:读读,这种情况不该加以限制. 程序就是要让锁对象知道当前读写状态,再根据情况对读写的线程进行锁定和解锁。

读写线程都要操作的数据类

读写线程都要操作的数据是链表datas。
注意其中try...finally 的写法,它保证了加锁解锁过程是成对调用的

 

lpublic class DataLib {
     private List<String> datas;
 
     private ReadWriteLock lock;
 
     public DataLib() {
         datas = new ArrayList<String>();
         lock = new ReadWriteLock();
     }
 
     // 写入数据,这时不能读取
     public void writeData(List<String> newDatas) {
         try {
             lock.writeLock();
             Test.sleep(2);
             datas=newDatas;
         } finally {
             lock.writeUnlock();
         }
     }
 
     // 读取数据,这时不能写入
     public List<String> readData() {
         try {
             lock.readLock();
             Test.sleep(1);            
             return datas;
         } finally {
             lock.readUnlock();
         }
 
     }
 
 }

读写锁ReadWriteLock类

public class ReadWriteLock{
    // 读状态
    private boolean isRead;
    
    // 写状态
    private boolean isWrite;
    
    public synchronized void readLock(){
        // 有写入时读取线程停止
        while(isWrite){
            try{    
                System.out.println("有线程在进行写入,读取线程停止,进入等待状态");
                wait();
            }
            catch(InterruptedException ex){
                ex.printStackTrace();
            }
        }
        
        System.out.println("设定锁为读取状态");
        isRead=true;
    }
    
    public synchronized void readUnlock(){
        System.out.println("解除读取锁");
        isRead=false;
        notifyAll();
    }

     public synchronized void writeLock(){
        // 有读取时读取线程停止
        while(isRead){
            try{    
                System.out.println("有线程在进行读取,写入线程停止,进入等待状态");
                wait();
            }
            catch(InterruptedException ex){
                ex.printStackTrace();
            }
        }
        
        // 有写入时写入线程也一样要停止
        while(isWrite){
            try{    
                System.out.println("有线程在进行写入,写入线程停止,进入等待状态");
                wait();
            }
            catch(InterruptedException ex){
                ex.printStackTrace();
            }
        }
        
        System.out.println("设定锁为写入状态");
        isWrite=true;
    }
    
    public synchronized void writeUnlock(){
        System.out.println("解除写入锁");
        isWrite=false;
        notifyAll();
    }
}

写线程类Writer -它用于往DataLib类实例中的datas字段写数据

分析其中dataLib字段的用意。
注意并记住其中持续调用及使用随机数的方法。

 

lpublic class Writer implements Runnable{
     private DataLib dataLib;
     private static final Random random=new Random();
     private String[] mockDatas={"甲","乙","丙","丁","戊","己","庚","辛","壬","癸"};    
     
     public Writer(DataLib dataLib,String[] mockDatas){
         this.dataLib=dataLib;
         this.mockDatas=mockDatas;
         
         Thread thread=new Thread(this);
         thread.start();
     }
     
     public void run(){
         while(true){
             Test.sleep(random.nextInt(3));
             
             int startIndex=random.nextInt(mockDatas.length);
             
             ArrayList<String> newDatas=new ArrayList<String>();
             for(int i=startIndex;i<mockDatas.length;i++){
                 newDatas.add(mockDatas[i]);
             }
             
             dataLib.writeData(newDatas);
         }
     }
 }

读线程类Reader  -它用于从DataLib类实例中的datas字段读取数据

分析其中dataLib字段的用意。
注意并记住其中持续调用及使用随机数的方法。

public class Reader implements Runnable{
    private DataLib dataLib;
    private static final Random random=new Random();
    
    public Reader(DataLib dataLib){
        this.dataLib=dataLib;
    
        Thread thread=new Thread(this);
        thread.start();
    }
    
    public void run(){
        while(true){
            Test.sleep(random.nextInt(2));            
            List<String> datas=dataLib.readData();
            
            System.out.print(">>取得数组为:");
            for(String data:datas){
                System.out.print(data+",");
            }
            System.out.print("\n");
        }
    }
}

将代码运行起来

右边的代码创建了两个写线程和三个读线程，它们都是对dataLib实例进行操作的。
五个线程都有一个dataLib字段，都提供了一个带参构造函数以给datas字段赋值，这就保证了五个线程操作的都是一个实例的同一字段，也就是同一片内存。
读写锁就是对这五个线程进行控制的。
当有一个读线程在操作时，其它的写线程无法进行操作，读线程可以正常操作，互不干扰。
当有一个写线程在操作时，其它的读线程无法进行操作。

 

 public class Test{
     public static void main(String[] args){
         DataLib dataLib=new DataLib();
         
         String[] mockDatas1={"甲","乙","丙","丁","戊","己","庚","辛","壬","癸"};
         Writer writer1=new Writer(dataLib,mockDatas1);
         
         String[] mockDatas2={"子","丑","寅","卯","辰","巳","午","未","申","酉","戌","亥"};
         Writer writer2=new Writer(dataLib,mockDatas2);
         
         Reader reader1=new Reader(dataLib);
         Reader reader2=new Reader(dataLib);
         Reader reader3=new Reader(dataLib);
     }
     
     
     // 用于延时
     public static void sleep(int sleepSecond){
         try{
             Thread.sleep(sleepSecond*1000);
         }
         catch(Exception ex){
             ex.printStackTrace();
         }
     }
 }

小结

当多个线程试图对同一内容进行读写操作时适合使用读写锁。
请理解并记住ReadWriteLock类读写锁的写法.
读写锁相对于线程互斥的优势在于高效，它不会对两个读线程进行盲目的互斥处理，当读线程数量多于写线程尤其如此，当全是写线程时两者等效。