Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
先看一个关于Condition使用的简单实例：
1 public class ConditionTest {
2 public static void main(String[] args) {
3 final Lock lock = new ReentrantLock();
4 final Condition condition = lock.newCondition();
5
6 Thread thread1 = new Thread(new Runnable() {
7 @Override
8 public void run() {
9 try {
10 lock.lock();
11 System.out.println("我需要等一个信号"+this);
12 condition.await();
13 System.out.println("我拿到一个信号"+this);
14 } catch (Exception e) {
15 // TODO: handle exception
16 } finally{
17 lock.unlock();
18 }
19
20
21 }
22 }, "thread1");
23 thread1.start();
24 Thread thread2 = new Thread(new Runnable() {
25 @Override
26 public void run() {
27 try {
28 lock.lock();
29 System.out.println("我拿到了锁");
30 Thread.sleep(500);
31 System.out.println("我发出一个信号");
32 condition.signal();
33 } catch (Exception e) {
34 // TODO: handle exception
35 } finally{
36 lock.unlock();
37 }
38
39
40 }
41 }, "thread2");
42 thread2.start();
43 }
44 }
运行结果：
1 我需要等一个信号com.luchao.traditionalthread.ConditionTest$1@10bc3c9 2 我拿到了锁 3 我发出一个信号 4 我拿到一个信号[email protected]
可以看到，Condition的执行方式，是当在线程1中调用await方法后，线程1将释放锁，并且将自己沉睡，等待唤醒，线程2获取到锁后，开始做事，完毕后，调用Condition的signal方法，唤醒线程1，线程1恢复执行。
以上说明Condition是一个多线程间协调通信的工具类，使得某个，或者某些线程一起等待某个条件（Condition）,只有当该条件具备( signal 或者 signalAll方法被带调用)时 ，这些等待线程才会被唤醒，从而重新争夺锁。
Condition与传统线程通信有些类似，它的使用更广，可以将多个线程进行通信，以完成更加复杂的通信。
用Condition替换传统线程通信，在前面的传统有一个子线程和主线程交替运行50次的实例，使用Condition也可以完成。
代码如下：
1 public class ConditionCommuniction {
2 public static void main(String[] args) {
3 final Business business = new Business();
4 new Thread(new Runnable() {
5 @Override
6 public void run() {
7 for (int i = 0; i < 50; i++) {
8 business.sub(i);
9 }
10 }
11 }).start();
12 for (int i = 0; i < 50; i++) {
13 business.main(i);
14 }
15 }
16
17
18 static class Business{
19 private Lock lock = new ReentrantLock();
20 private boolean isMain = true;
21 private Condition condition = lock.newCondition();
22 public void main(int i){
23 lock.lock();
24 try {
25 while(!isMain){
26 condition.await();
27 }
28 for (int j = 0; j < 100; j++) {
29 System.out.println("main is looping :" + j +" in " + i);
30 }
31 isMain = false;
32 condition.signal();
33 } catch (Exception e) {
34 // TODO: handle exception
35 } finally{
36 lock.unlock();
37 }
38 }
39 public void sub(int i){
40 lock.lock();
41 try {
42 while(isMain){
43 condition.await();
44 }
45 for (int j = 0; j < 10; j++) {
46 System.out.println("sub is looping :" + j +" in " + i);
47 }
48 isMain = true;
49 condition.signal();
50 } catch (Exception e) {
51 // TODO: handle exception
52 } finally{
53 lock.unlock();
54 }
55 }
56 }
57 }
在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现，这里注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。
这样看来，Condition和传统的线程通信没什么区别，Condition的强大之处在于它可以为多个线程间建立不同的Condition，下面引入API中的一段代码，加以说明。
1 class BoundedBuffer {
2 final Lock lock = new ReentrantLock();//锁对象
3 final Condition notFull = lock.newCondition();//写线程条件
4 final Condition notEmpty = lock.newCondition();//读线程条件
5
6 final Object[] items = new Object[100];//缓存队列
7 int putptr/*写索引*/, takeptr/*读索引*/, count/*队列中存在的数据个数*/;
8
9 public void put(Object x) throws InterruptedException {
10 lock.lock();
11 try {
12 while (count == items.length)//如果队列满了
13 notFull.await();//阻塞写线程
14 items[putptr] = x;//赋值
15 if (++putptr == items.length) putptr = 0;//如果写索引写到队列的最后一个位置了，那么置为0
16 ++count;//个数++
17 notEmpty.signal();//唤醒读线程
18 } finally {
19 lock.unlock();
20 }
21 }
22
23 public Object take() throws InterruptedException {
24 lock.lock();
25 try {
26 while (count == 0)//如果队列为空
27 notEmpty.await();//阻塞读线程
28 Object x = items[takeptr];//取值
29 if (++takeptr == items.length) takeptr = 0;//如果读索引读到队列的最后一个位置了，那么置为0
30 --count;//个数--
31 notFull.signal();//唤醒写线程
32 return x;
33 } finally {
34 lock.unlock();
35 }
36 }
37 }
这就是多个Condition的强大之处，假设缓存队列中已经存满，那么阻塞的肯定是写线程，唤醒的肯定是读线程，相反，阻塞的肯定是读线程，唤醒的肯定是写线程，那么假设只有一个Condition会有什么效果呢，缓存队列中已经存满，这个Lock不知道唤醒的是读线程还是写线程了，如果唤醒的是读线程，皆大欢喜，如果唤醒的是写线程，那么线程刚被唤醒，又被阻塞了，这时又去唤醒，这样就浪费了很多时间。
将上面主线程和子线程交替运行的程序进行扩展，三个线程交替运行，代码如下：
1 public class ThreeConditionCommunication {
2 public static void main(String[] args) {
3 final Business business = new Business();
4 new Thread(new Runnable() {
5
6 @Override
7 public void run() {
8 for (int i = 0; i < 50; i++) {
9 business.sub1(i);
10 }
11 }
12 }).start();
13 new Thread(new Runnable() {
14
15 @Override
16 public void run() {
17 for (int i = 0; i < 50; i++) {
18 business.sub2(i);
19 }
20 }
21 }).start();
22 for (int i = 0; i < 50; i++) {
23 business.main(i);
24 }
25 }
26 static class Business{
27 Lock lock = new ReentrantLock();
28 Condition main = lock.newCondition();
29 Condition sub1 = lock.newCondition();
30 Condition sub2 = lock.newCondition();
31 int runNum = 1;
32
33 public void main(int i){
34 lock.lock();
35 try {
36 while(runNum!=1){
37 main.await();//主线程等待
38 }
39 for (int j = 0; j < 100; j++) {
40 System.out.println("main is looping of "+j+" in "+i);
41 }
42 runNum = 2;
43 sub1.signal();//唤醒子线程1
44 } catch (Exception e) {
45 // TODO: handle exception
46 } finally{
47 lock.unlock();
48 }
49 }
50 public void sub1(int i){
51 lock.lock();
52 try {
53 while(runNum!=2){
54 sub1.await();//子线程1等待
55 }
56 for (int j = 0; j < 10; j++) {
57 System.out.println("sub1 is looping of "+j+" in "+i);
58 }
59 runNum = 3;
60 sub2.signal();//唤醒子线程2
61 } catch (Exception e) {
62 // TODO: handle exception
63 } finally{
64 lock.unlock();
65 }
66 }
67 public void sub2(int i){
68 lock.lock();
69 try {
70 while(runNum!=3){
71 sub2.await();//子线程2等待
72 }
73 for (int j = 0; j < 20; j++) {
74 System.out.println("sub2 is looping of "+j+" in "+i);
75 }
76 runNum = 1;
77 main.signal();//唤醒主线程
78 } catch (Exception e) {
79 // TODO: handle exception
80 } finally{
81 lock.unlock();
82 }
83 }
84 }
85 }
由此可见，Condition在多线程通信的强大作用，可以大大提高程序效率。
时间： 2024-11-05 14:52:41