1.使用Condition实现等待/通知:错误用法与解决
关键字synchronized与wait()和notify()、notifyAll()方法相结合可以实现等待/通知模式,类ReetrantLock也可以实现同样的功能,但需要借助于Condition对象。Condition类是在JDK5中出现的技术,使用它有更好的灵活性,使用它有更好的灵活性,比如可以实现多路通知功能,也就是在一个Lock对象里面可以创建多个Condition(即对象监控器)示例,线程对象可以注册在指定的Condition中,从而可以有选择性地进行通知,在调度线程上更加灵活。
在使用notify/notifyAll方法进行通知时,被通知的线程却是由JVM随机选择的。但使用ReentrantLock结合Condition类是可以实现前面介绍的”选择性通知“,这个功能是非常重要的,而且在Condition类中是默认提供的。
而synchronized就相当于整个Lock对象中只有一个单一的Condition对象,所有的线程都注册在它一个对象的身上。线程开始notifyAll时,需要通知所有的等待线程,没有选择权,会出现相当大的效率问题。
示例代码:
package ConditionTest;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author LiBinquan
*/
public class MyService {
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void await(){
try{
condition.await();
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
线程A:
package ConditionTest;
/**
* @Author LiBinquan
*/
public class ThreadA extends Thread{
private MyService service;
public ThreadA(MyService service){
this.service = service;
}
@Override
public void run() {
service.await();
}
}
运行类:
package ConditionTest;
/**
* @Author LiBinquan
*/
public class Run {
public static void main(String[] args) {
MyService service = new MyService();
ThreadA a = new ThreadA(service);
a.start();
}
}
输出:

由输出可得,报错的异常信息是监视器出错,解决的办法是必须在Condition.await方法调用之前调用lock.lock代码获得同步监视器。
修改MyService类:
package ConditionTest;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author LiBinquan
*/
public class MyService {
private ReentrantLock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void await(){
try{
lock.lock();
System.out.println(
"A"
);
condition.await();
System.out.println("B");
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
输出:

控制台只打印了A,是因为Condition.await()使线程呈等待状态。
2.正确使用Condition实现等待/通知
示例代码:
MyService类:
package ConditionTest;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author LiBinquan
*/
public class MyService {
private Lock lock = new ReentrantLock();
public Condition condition = lock.newCondition();
public void await(){
try{
lock.lock();
System.out.println(" await 时间为 "+System.currentTimeMillis());
condition.await();
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void signal(){
try{
lock.lock();
System.out.println("signal 时间为 "+System.currentTimeMillis());
condition.signal();
}finally {
lock.unlock();
}
}
}
线程A:
package ConditionTest;
/**
* @Author LiBinquan
*/
public class ThreadA extends Thread{
private MyService service;
public ThreadA(MyService service){
this.service = service;
}
@Override
public void run() {
service.await();
}
}
运行类:
package ConditionTest;
/**
* @Author LiBinquan
*/
public class Run {
public static void main(String[] args) throws InterruptedException{
MyService service = new MyService();
ThreadA a = new ThreadA(service);
a.start();
Thread.sleep(3000);
service.signal();
}
}
输出:

由输出可知,实现了等待、通知模式。
Object类中的wait()方法相当于Condition类中的await()。
Object类中的wait(long timeOut)方法相当于Condition类中的await(long time,TimeUnit unit)方法。
Object类中的notify()方法相当于Condition类中的signal()方法。
Object类中的notifyAll()方法相当于Condition类中的signalAll()方法。
3.使用多个Condition实现通知部分线程:错误用法
package ConditionTest;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author LiBinquan
*/
public class MyService {
private Lock lock = new ReentrantLock();
public Condition condition = lock.newCondition();
public void awaitA(){
try{
lock.lock();
System.out.println("begin awaitA 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
condition.await();
System.out.println(" end awaitA 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void awaitB(){
try{
lock.lock();
System.out.println("begin awaitB 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
condition.await();
System.out.println(" end awaitB 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void signalAll(){
try{
lock.lock();
System.out.println("signalAll 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
condition.signalAll();
}finally {
lock.unlock();
}
}
}
线程A:
package ConditionTest;
/**
* @Author LiBinquan
*/
public class ThreadA extends Thread{
private MyService service;
public ThreadA(MyService service){
this.service = service;
}
@Override
public void run() {
service.awaitA();
}
}
线程B:
package ConditionTest;
/**
* @Author LiBinquan
*/
public class ThreadB extends Thread{
private MyService service;
public ThreadB(MyService service){
this.service = service;
}
@Override
public void run() {
service.awaitB();
}
}
运行类:
package ConditionTest;
/**
* @Author LiBinquan
*/
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和线程B都被唤醒了。
那么单独唤醒部分程序就需要用到多个Condition对象了,也就是Condition对象可以唤醒部分指定线程,有助于提升程序运行的效率。可以先对线程进行分组,然后再唤醒指定组中的线程。
4.使用多个Condition实现通知部分线程:正确用法
修改MyService类
package ConditionTest;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author LiBinquan
*/
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("begin awaitA 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
conditionA.await();
System.out.println(" end awaitA 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void awaitB(){
try{
lock.lock();
System.out.println("begin awaitB 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
conditionB.await();
System.out.println(" end awaitB 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void signalAll_A(){
try{
lock.lock();
System.out.println("signalAll 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
conditionA.signalAll();
}finally {
lock.unlock();
}
}
public void signalAll_B(){
try{
lock.lock();
System.out.println("signalAll 时间为 "+System.currentTimeMillis()+" ThreadName = "+Thread.currentThread().getName());
conditionB.signalAll();
}finally {
lock.unlock();
}
}
}
修改运行类:
package ConditionTest;
/**
* @Author LiBinquan
*/
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();
}
}
输出:

5.实现生产者/消费者模式:一对一交替打印
示例代码:
package ConditionTest;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author LiBinquan
*/
public class MyService2 {
private ReentrantLock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
private boolean hasValue = false;
public void set(){
try{
lock.lock();
while (hasValue == true){
condition.await();
}
System.out.println("打印★");
hasValue = true;
condition.signal();
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void get(){
try {
lock.lock();
while (hasValue == false){
condition.await();
}
System.out.println("打印☆");
hasValue = false;
condition.signal();
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
线程A:
package ConditionTest;
/**
* @Author LiBinquan
*/
public class MyThreadA extends Thread{
private MyService2 service;
public MyThreadA(MyService2 service){
this.service = service;
}
@Override
public void run() {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
service.set();
}
}
}
线程B:
package ConditionTest;
/**
* @Author LiBinquan
*/
public class MyThreadB extends Thread{
private MyService2 service;
public MyThreadB(MyService2 service){
this.service = service;
}
@Override
public void run() {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
service.get();
}
}
}
运行类:
package ConditionTest;
/**
* @Author LiBinquan
*/
public class Run {
public static void main(String[] args) throws InterruptedException{
MyService2 service = new MyService2();
MyThreadA a = new MyThreadA(service);
a.setName("A");
a.start();
MyThreadB b = new MyThreadB(service);
b.setName("B");
b.start();
}
}
输出:

6.实现生产者/消费者模式:多对多交替打印
示例:
package ConditionTest;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author LiBinquan
*/
public class MyService3 {
private ReentrantLock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
private boolean hasValue = false;
public void set(){
try{
lock.lock();
while (hasValue == true){
System.out.println("有可能★★ 连续");
condition.await();
}
System.out.println("打印★");
hasValue = true;
condition.signal();
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void get(){
try {
lock.lock();
while (hasValue == false){
System.out.println("有可能☆☆ 连续");
condition.await();
}
System.out.println("打印☆");
hasValue = false;
condition.signal();
}catch (InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
运行类:
package ConditionTest;
/**
* @Author LiBinquan
*/
public class Run {
public static void main(String[] args) throws InterruptedException{
MyService3 service = new MyService3();
MyThreadA[] threadA = new MyThreadA[10];
MyThreadB[] threadB = new MyThreadB[10];
for (int i = 0; i < 10; i++) {
threadA[i] = new MyThreadA(service);
threadB[i] = new MyThreadB(service);
threadA[i].start();
threadB[i].start();
}
}
}
输出:

这个连续的打印可以使用siganlAll方法来解决。将MyService3类中的两处signal代码给成siganlAll,程序得到运行后就会正确。
可以发现这样也解决了假死问题。
还是会出现连续打印出现,这个问题的原因是因为使用了一个Condition对象,,再结合signalAll方法来唤醒所有的线程,那么唤醒的线程就有可能是同类,所以就出现了连续打印的情况。
本文详细介绍了Java中多线程环境下Condition的使用,包括错误用法及解决办法,正确实现等待/通知模式,以及如何通过多个Condition实现选择性通知,最后展示了在生产者/消费者模式中的应用案例。

被折叠的 条评论
为什么被折叠?



