Java之多线程开发时多条件Condition接口的使用

转：http://blog.csdn.net/a352193394/article/details/39454157

我们在多线程开发中，可能会出现这种情况。就是一个线程需要另外一个线程满足某某条件才能继续运行，或者需

要其他线程满足好几个条件才能运行，对于这样的多条件的多线程并发，我们如何控制好各个线程之间的关系，使他们

能很好的处理冲突不至于相互出现问题呢，下面我们来介绍一下Java提供的Condition这个接口，这个接口很好的实现了

这种需求。

对于这个问题最经典的例子就是生产者消费者模型，生产者当缓冲区满的时候不生产商品知道缓冲区有空余，消费

者当缓冲区为0 的时候不拿商品，直到生产者向缓冲区放入商品，下面我们使用Conditon这个接口来实现这样的需求。

[java] view plaincopyprint?

1. import java.util.concurrent.ExecutorService;
2. import java.util.concurrent.Executors;
3. import java.util.concurrent.locks.Condition;
4. import java.util.concurrent.locks.Lock;
5. import java.util.concurrent.locks.ReentrantLock;
6. /**
7. * 有时候线程取得lock后需要在一定条件下才能做某些工作，比如说经典的Producer和Consumer问题。
8. * 在Java 5.0以前，这种功能是由Object类的wait(), notify()和notifyAll()等方法实现的，
9. * 在5.0里面，这些功能集中到了Condition这个接口来实现。
10. */
11. public class ConditionTest {
12. /**
13. * 篮子程序，这里为了简化问题，篮子中最多只能有一个苹果。
14. * Consumer必须在篮子里有苹果的时候才能吃苹果，否则它必须暂时放弃对篮子的锁定，
15. * 等到Producer往篮子里放了苹果后再去拿来吃。而Producer必须等到篮子空了才能往里放苹果，
16. * 否则它也需要暂时解锁等Consumer把苹果吃了才能往篮子里放苹果。
17. */
18. public static class Basket {
19. // 锁
20. Lock lock = new ReentrantLock();
21. //  根据锁产生Condition对象
22. Condition produced = lock.newCondition();
23. Condition consumed = lock.newCondition();
24. // 篮子中的苹果数，最多为1
25. int num = 0;
26. /**
27. * 生产苹果，往篮子里放
28. * @throws InterruptedException
29. */
30. public void produce() throws InterruptedException {
31. // 获得锁
32. lock.lock();
33. System.out.println("Producer get a lock...");
34. try {
35. // 判断是否满足生产条件
36. while (num == 1) {
37. // 如果有苹果，则不生产，放弃锁，进入睡眠
38. // 等待消费者消费
39. System.out.println("Producer sleep...");
40. consumed.await();
41. System.out.println("Producer awaked...");
42. }
43. /*生产苹果*/
44. Thread.sleep(500);
45. System.out.println("Producer produced an Apple.");
46. num = 1;
47. // 通知等待produced Condition的线程
48. produced.signal();
49. } finally {
50. lock.unlock();
51. }
52. }
53. /**
54. * 消费苹果，从篮子中取
55. * @throws InterruptedException
56. */
57. public void consume() throws InterruptedException {
58. // 获得锁
59. lock.lock();
60. System.out.println("Consumer get a lock...");
61. try {
62. // 判断是否满足消费条件
63. while (num == 0) {
64. // 如果没有苹果，无法消费，则放弃锁，进入睡眠
65. // 等待生产者生产苹果
66. System.out.println("Consumer sleep...");
67. produced.await();
68. System.out.println("Consumer awaked...");
69. }
70. /*吃苹果*/
71. Thread.sleep(500);
72. System.out.println("Consumer consumed an Apple.");
73. num = 0;
74. // 发信号唤醒某个等待consumed Condition的线程
75. consumed.signal();
76. } finally {
77. lock.unlock();
78. }
79. }
80. }
81. /**
82. * 测试Basket程序
83. */
84. public static void testBasket() throws Exception {
85. final Basket basket = new Basket();
86. //  定义一个producer
87. Runnable producer = new Runnable() {
88. public void run() {
89. try {
90. basket.produce();
91. } catch (InterruptedException ex) {
92. ex.printStackTrace();
93. }
94. }
95. };
96. // 定义一个consumer
97. Runnable consumer = new Runnable() {
98. public void run() {
99. try {
100. basket.consume();
101. } catch (InterruptedException ex) {
102. ex.printStackTrace();
103. }
104. }
105. };
106. //  各产生3个consumer和producer
107. ExecutorService service = Executors.newCachedThreadPool();
108. for (int i = 0; i < 3; i++){
109. service.submit(producer);
110. }
111. for (int i = 0; i < 3; i++){
112. service.submit(consumer);
113. }
114. service.shutdown();
115. }
116. public static void main(String[] args) throws Exception {
117. ConditionTest.testBasket();
118. }
119. }