ReentrantLock使用Condition实现通知部分线程

关键字synchronized与wait()和notify()/notifyAll()方法想结合可以实现等待/通知模式，类ReentrantLock也可以实现同样的功能，但需要借助于Condition对象。Condition类在JDK5中出现，使用它有更好的灵活性，比如可以实现多路通知的功能，也就是在一个Lock对象中可以创建多个Condition对象（对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择地进行线程通知，在调度线程上更加灵活。

编程举例：

Service类，包含等待和通知的同步方法。

package lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyService {
private Lock lock = new ReentrantLock();

public Condition conditionA = lock.newCondition();
public Condition conditionB = lock.newCondition();

public void awaitA(){
try{
lock.lock();
System.out.println("thread "+Thread.currentThread().getName()+" wait begin,in awaitA method");
conditionA.await(); //使用conditionA进行等待
System.out.println("thread "+Thread.currentThread().getName()+" end wait,in awaitA method");
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}

public void awaitB(){
try{
lock.lock();
System.out.println("thread "+Thread.currentThread().getName()+" wait begin,in awaitB method");
conditionB.await();   //使用conditionB进行等待
System.out.println("thread "+Thread.currentThread().getName()+" end wait,in awaitB method");
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}

public void signalAll_A(){
try{
lock.lock();
System.out.println("现在要通知所在在conditionA上等待的线程 "+Thread.currentThread().getName());
conditionA.signalAll();  //通知所有在conditionA上等待的线程
}finally {
lock.unlock();
}
}
public void signalAll_B(){
try{
lock.lock();
System.out.println("现在要通知所在在conditionB上等待的线程 "+Thread.currentThread().getName());
conditionB.signalAll();
}finally {
lock.unlock();
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
5657
58


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
线程A类，A类线程使用conditionA进行等待。

package lock;

public class ThreadA extends Thread{

private MyService service;

public ThreadA(MyService service){
super();
this.service = service;
}

@Override
public void run(){
service.awaitA();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
B类线程，B类线程使用conditionB进行等待。

package lock;

public class ThreadB extends Thread{

private MyService service;

public ThreadB(MyService service){
super();
this.service = service;
}

@Override
public void run(){
service.awaitB();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
测试类，调用Service类的signalAll_A方法，只通知在conditionA上等待的线程：

package lock;

public class Run {

public static void main(String[] args) throws InterruptedException {
MyService service = new MyService();
ThreadA a = new ThreadA(service);
a.setName("A");
a.start();
ThreadB b = new ThreadB(service);
b.setName("B");
b.start();
Thread.sleep(3000);
service.signalAll_A();  //只通知在conditionA上等待的线程。
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
程序输出如下：

thread A wait begin,in awaitA method
thread B wait begin,in awaitB method
现在要通知所在在conditionA上等待的线程 main
thread A end wait,in awaitA method

1
2
3
4


1
2
3
4
由此可见线程B没有被唤醒。

在使用Condition实现等待通知时：

Object类中的wait（）方法相当于Condition类的await（）方法。

Object类中的wait(long timeout)方法相当于Condition类中的await(long time,TimeUnit unit)方法。

Object类中的notify()方法相当于Condition类中的signal()方法。

Object类中的notifyAll()方法相当于Condition类中的signalAll()方法。

参考《Java多线程编程核心技术》



顶 0 踩 0
 
 
上一篇使用ReentrantLock实现线程同步
下一篇使用ReentrantReadWriteLock类

我的同类文章

Java/多线程（34）
http://blog.csdn.net
•Java阻塞队列ArrayBlockingQueue和LinkedBlockingQueue实现原理分析（还没看，先马）2016-09-12阅读283
•并行编程框架 ForkJoin（介绍了一点原理，可扩展）2016-09-09阅读414
•akka introduce2016-08-18阅读134
•《实战Java...》读书笔记22016-08-14阅读95
•Java NIO 总结与示例2016-08-14阅读240
•倒计时器：CountDownLatch2016-08-12阅读76
•Java 理论与实践: 应用 fork-join 框架（转自ibm）2016-09-09阅读104
•《Java性能优化...》读书笔记2016-08-20阅读207
•Java AIO总结与示例2016-08-16阅读1261
•《实战Java...》读书笔记2016-08-14阅读80
•一个并行搜索算法2016-08-13阅读289
更多文章