java多线程（七）提高锁的效率——使用读写锁

之前我们讲过ReentrantLock，这种锁不区分读操作和写操作，如果有一个线程在执行读操作，那么其他的所有的线程不能进行任何的读操作或者写操作。这样可以保证程序的互斥性，但是降低了程序的并发性，使执行效率降低，没有有效的发挥多线程的优势。比如说，有一个系统，主要是以读操作为主，比如有10个线程负责读数据，只有一个线程负责写数据。如果用我们之前的ReentrantLock方法，这10个线程中没有哪两个线程是可以同时执行的，但是我们仔细想一下，如果一个线程在执行读操作，那么其他的读线程可以执行吗？当然是可以的啊，因为读操作不会改变数据，自然不会造成数据错误，所以针对这种情况，java中有一个ReentrantReadWriteLock，用来控制读写操作。

这种锁分为两种，读锁和写锁。如果一个线程获得了读锁，那么其他的执行读操作的线程可以继续获得该读锁，也就是说读操作可以并发的执行，但是其他的写锁将会被阻塞。如果一个线程获得了写锁，那么其他的任何试图获得读锁和写锁的线程都将被阻塞。

我们来看一个例子：

[java]  view plain copy

1. import java.util.concurrent.locks.Lock;  
2. import java.util.concurrent.locks.ReentrantReadWriteLock;  
3.   
4. public class ReadWrite {  
5.     private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();  
6.     private Lock readLock;  
7.     private Lock writeLock;  
8.     private int num = -1;  
9.   
10.     public ReadWrite() {  
11.         readLock = lock.readLock();  
12.         writeLock = lock.writeLock();  
13.     }  
14.       
15.     public void read(){  
16.         while(true){  
17.             try{  
18.                 readLock.lock();  
19.                 System.out.println(Thread.currentThread()+"准备读取数据!");  
20.                 Thread.sleep(1000);  
21.                 System.out.println(Thread.currentThread()+"读取的数据为"+num);  
22.             }catch(Exception e){  
23.                 e.printStackTrace();  
24.             }finally{  
25.                 readLock.unlock();  
26.             }  
27.         }  
28.           
29.     }  
30.       
31.     public void write(){  
32.         while(true){  
33.             try{  
34.                 writeLock.lock();  
35.                 System.out.println(Thread.currentThread()+"准备写入数据");  
36.                 Thread.sleep(1000);  
37.                 num = (int)(Math.random()*10);  
38.                 System.out.println(Thread.currentThread()+"已经写入数据"+num);  
39.             }catch(Exception e){  
40.                 e.printStackTrace();  
41.             }finally{  
42.                 writeLock.unlock();  
43.             }  
44.         }  
45.           
46.     }  
47. }  

[java]  view plain copy

1. public class Main {  
2.   
3.     public static void main(String[] args) {  
4.         final ReadWrite rd = new ReadWrite();  
5.           
6.         for(int i=0;i<3;i++){  
7.             new Thread(new Runnable() {  
8.                   
9.                 @Override  
10.                 public void run() {  
11.                     rd.read();  
12.                 }  
13.             }).start();;  
14.         }  
15.           
16.         new Thread(new Runnable() {  
17.               
18.             @Override  
19.             public void run() {  
20.                 rd.write();  
21.             }  
22.         }).start();  
23.     }  
24.   
25. }  

在ReadWrite类中声明了一个ReentrantReadWriteLock和一个int型的变量，ReentrantReadWriteLock中有两个方法readLock（）和writeLock（），分别用来获得读锁和写锁。ReadWrite类有read和write，分别用来读取num的值和改变num的值。在主程序中，有三个线程负责读数据，一个线程负责写数据。运行效果如下：

我们可以清楚的看到，三个读取的线程是同时执行的，但是写操作是不能喝读操作一起执行的。所以以后在执行读操作和写操作时可以考虑使用读写锁。