多线程之condition使用

本文详细介绍了Java中多线程环境下Condition的使用,包括错误用法及解决办法,正确实现等待/通知模式,以及如何通过多个Condition实现选择性通知,最后展示了在生产者/消费者模式中的应用案例。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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方法来唤醒所有的线程,那么唤醒的线程就有可能是同类,所以就出现了连续打印的情况。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值