Java并发之读写锁Lock和条件阻塞Condition的应用

Java 5中提供了另一种实现线程同步或互斥的机制，即使用Lock和Condition。

Lock比传统线程模型中的synchronized方式更加面向对象，也提供了更多可选择的锁机制。与生活中的锁类似，锁本身也是一个对象。两个线程执行的代码片段要实现同步互斥的效果，它们必须使用同一个Lock对象。锁是上在代表要操作的资源的类的内部方法中，而不是线程代码中。

 

Lock使用示例：

 

 1 import java.util.concurrent.locks.Lock;
 2 import java.util.concurrent.locks.ReentrantLock;
 3 
 4 // An example of using Lock.
 5 public class LockTest {
 6 
 7     public static void main(String[] args) {
 8         new LockTest().init();
 9 
10     }
11 
12     private void init() {
13         final Outputer outputer = new Outputer();
14         new Thread(new Runnable() {
15             @Override
16             public void run() {
17                 while (true) {
18                     try {
19                         Thread.sleep(10);
20 
21                     } catch(InterruptedException e) {
22                         e.printStackTrace();
23 
24                     }
25                     outputer.output("aaaaaaaaaaa");
26 
27                 }
28 
29 
30             }
31 
32         }).start();
33 
34         new Thread(new Runnable() {
35             @Override
36             public void run() {
37                 while (true) {
38                     try {
39                         Thread.sleep(10);
40 
41                     } catch(InterruptedException e) {
42                         e.printStackTrace();
43 
44                     }
45                     outputer.output("bbbbbbbbbbb");
46 
47                 }
48 
49 
50             }
51 
52         }).start();
53 
54 
55     }
56 
57     static class Outputer {
58         private Lock lock = new ReentrantLock();
59         public void output(String name) {
60             int len = name.length();
61             lock.lock();
62             try {
63                 for (int i = 0; i < len; i++) {
64                     System.out.print(name.charAt(i));
65 
66                 }
67                 System.out.println();
68 
69             } finally {
70                 lock.unlock();
71 
72             }
73 
74         }
75 
76     }
77 
78 }

 

读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是由JVM控制的，我们只需要上好相应的锁即可。如果代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果代码修改数据，只能有一个人在写，并不能同时读取，那就上写销锁。总之，读的时候上读锁，写的时候上写锁。

Java读写锁示例：

 

 1 import java.util.Random;
 2 import java.util.concurrent.locks.ReadWriteLock;
 3 import java.util.concurrent.locks.ReentrantReadWriteLock;
 4  
 5 public class ReadWriteLockTest {
 6     public static void main(String[] args) {
 7         final MyQueue queue = new MyQueue();
 8         for (int i = 0; i < 3; i++) {
 9             new Thread() {
10                 public void run() {
11                     while (true) {
12                         queue.get();
13                     }
14                 }
15  
16             }.start();
17  
18             new Thread() {
19                 public void run() {
20                     while (true) {
21                         queue.put(new Random().nextInt(10000));
22                     }
23                 }
24  
25             }.start();
26         }
27  
28     }
29 }
30  
31 class MyQueue {
32     // 共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
33     private Object data = null; 
34     ReadWriteLock  rwl  = new ReentrantReadWriteLock();
35  
36     public void get() {
37         rwl.readLock().lock();
38         try {
39             System.out.println(Thread.currentThread().getName()
40                     + " be ready to read data!");
41             Thread.sleep((long) (Math.random() * 1000));
42             System.out.println(Thread.currentThread().getName()
43                     + "have read data :" + data);
44         } catch (InterruptedException e) {
45             e.printStackTrace();
46         } finally {
47             rwl.readLock().unlock();
48         }
49     }
50  
51     public void put(Object data) {
52  
53         rwl.writeLock().lock();
54         try {
55             System.out.println(Thread.currentThread().getName()
56                     + " be ready to write data!");
57             Thread.sleep((long) (Math.random() * 1000));
58             this.data = data;
59             System.out.println(Thread.currentThread().getName()
60                     + " have write data: " + data);
61         } catch (InterruptedException e) {
62             e.printStackTrace();
63         } finally {
64             rwl.writeLock().unlock();
65         }
66     }
67     
68 }

 

 

 

使用

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 import java.util.concurrent.locks.ReadWriteLock;
 4 import java.util.concurrent.locks.ReentrantReadWriteLock;
 5 
 6 // Using a ReadWriteLock to implement a cache.
 7 public class CacheDemo {
 8 
 9     private Map < String,
10     Object > cache = new HashMap < String,
11     Object > ();
12     private ReadWriteLock rwl = new ReentrantReadWriteLock();
13 
14     public static void main(String[] args) {
15         CacheDemo cache = new CacheDemo();
16         Object obj = cache.getData("");
17         System.out.println(obj.toString());
18 
19     }
20 
21     // Get the value from DB if the value does not exist,and then return it.
22     public Object getData(String key) {
23         rwl.readLock().lock();
24         Object value = null;
25         try {
26             value = cache.get(key);
27             if (value == null) {
28                 // Must release read lock before acquiring write lock
29                 rwl.readLock().unlock();
30                 rwl.writeLock().lock();
31                 try {
32                     // Recheck state because another thread might have acquired
33                     // write lock and changed state before we did.
34                     if (value == null) {
35                         // Here may access Database.
36                         // ...
37                         value = "Data";
38 
39                     }
40 
41                 } finally {
42                     rwl.writeLock().unlock();
43 
44                 }
45                 rwl.readLock().lock();
46 
47             }
48 
49         } finally {
50             rwl.readLock().unlock();
51 
52         }
53         return value;
54 
55     }
56 
57 }

 

 

：

 

Condition的功能类似在传统线程技术中的Object.wait和Object.notity的功能。在等待Condition时，允许发生“虚假唤醒”，这通常作为对基础平台语义的让步。对于大多数应用程序，这带来的实际影响很小，因为Condition应该总是在一个循环中被等待，并测试正被等待的状态声明。某个实现可以随意移除可能的虚假唤醒，但建议应用程序员总是假定这些虚假唤醒可能发生，因此总是在一个循环中等待。

 

一个锁内部可以有多个Condition，即有多路等待和通知，可以参看Jdk1.5提供的Lock和Condition实现的可阻塞队列的应用案例。在传统的线程机制中一个监视器对象上只能有一路等待和通知，要想实现多路等待和通知，必须嵌套使用多个同步监视器对象。

 

JDK文档中提供了一个很不错的示例（http://docs.oracle.com/javase/6/docs/api/ ），用Condition实现一个阻塞队列，代码如下：

 

 1 import java.util.concurrent.locks.Condition;
 2 import java.util.concurrent.locks.Lock;
 3 import java.util.concurrent.locks.ReentrantLock;
 4 
 5 public class BoundedBuffer {
 6     final Lock lock = new ReentrantLock();
 7     final Condition notFull = lock.newCondition();
 8     final Condition notEmpty = lock.newCondition();
 9 
10     final Object[] items = new Object[100];
11     int putptr,
12     takeptr,
13     count;
14 
15     public void put(Object x) throws InterruptedException {
16         lock.lock();
17         try {
18             while (count == items.length)
19             notFull.await();
20             items[putptr] = x;
21             if (++putptr == items.length)
22             putptr = 0;
23             ++count;
24             notEmpty.signal();
25 
26         } finally {
27             lock.unlock();
28 
29         }
30 
31     }
32 
33     public Object take() throws InterruptedException {
34         lock.lock();
35         try {
36             while (count == 0)
37             notEmpty.await();
38             Object x = items[takeptr];
39             if (++takeptr == items.length)
40             takeptr = 0;
41             --count;
42             notFull.signal();
43             return x;
44 
45         } finally {
46             lock.unlock();
47 
48         }
49 
50     }
51 
52 }