java多线程实现生产者与消费者

最新推荐文章于 2024-02-22 16:56:56 发布

Airbundey

最新推荐文章于 2024-02-22 16:56:56 发布

阅读量574

点赞数 1

CC 4.0 BY-SA版权

文章标签：多线程生产者与消费者

本文链接：https://blog.youkuaiyun.com/amanicspater/article/details/76188440

本文通过一个具体的Java实现案例，展示了如何使用synchronized关键字配合wait和notify方法来实现生产者消费者模式。该模式能够有效地解决多线程之间的同步问题，确保在资源有限的情况下，生产者与消费者能够有序地进行生产和消费。

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

只是自己的理解有错误还请指出：

工厂类：

public class MyFactory {

    private int foodNum = 0;

    public int getFoodNum() {
        return foodNum;
    }

    public void setFoodNum(int foodNum) {
        this.foodNum = foodNum;
    }

    public void consume(){
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.foodNum--;
    }

    public void produce(){
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.foodNum++;
    }
}

消费者类：

public class ConsumerThread implements Runnable {
    private MyFactory myFactory =null;

    public ConsumerThread(MyFactory factory){
        this.myFactory = factory;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {

            synchronized (this.myFactory){
                try{
                    Thread.sleep(10);
                    while(this.myFactory.getFoodNum() <= 0){
                        System.out.println("仓库里面没有库存了，请通知生产者去生产");
                        this.myFactory.wait();          //放弃工厂的使用权：锁
                    }
                    myFactory.consume();
                    myFactory.notifyAll();             //消费完了之后通知那些阻塞的生产者线程可以生产了
                    System.out.println("消费完了之后还有"+myFactory.getFoodNum()+"个零件");
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

生产者类：

public class ProducerThread implements Runnable {
    private MyFactory myFactory = null;

    public ProducerThread (MyFactory factory){
        this.myFactory = factory;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            synchronized (this.myFactory){
                try{
                    Thread.sleep(100);
                    while (this.myFactory.getFoodNum() >= 10){//库存满了
                        System.out.println("仓库库存为10（满额），进入等待状态,等待消费者取消费");
                        this.myFactory.wait();
                    }
                    myFactory.produce();
                    System.out.println("生产完了之后有"+myFactory.getFoodNum()+"个零件");
                    myFactory.notifyAll();//生产完了知乎通知那些阻塞的消费者线程可以消费了
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

            }
        }
    }
}

测试类：

/**
 * 测试使用wait和notify来模拟生产者与消费者
 * 其中用到了很多sleep来模拟不确定因素
 * Created by amanicspater on 2017/7/26.
 */
public class Main {
    public static void main(String[] args) {
        MyFactory myFactory = new MyFactory();
        Thread producerthread = new Thread(new ProducerThread(myFactory));
        Thread consumerthread = new Thread(new ConsumerThread(myFactory));
        producerthread.start();
        consumerthread.start();
    }

}

打印结果：

生产完了之后有1个零件
生产完了之后有2个零件
生产完了之后有3个零件
生产完了之后有4个零件
生产完了之后有5个零件
生产完了之后有6个零件
生产完了之后有7个零件
生产完了之后有8个零件
生产完了之后有9个零件
生产完了之后有10个零件
仓库库存为10（满额），进入等待状态,等待消费者取消费
消费完了之后还有9个零件
消费完了之后还有8个零件
消费完了之后还有7个零件
消费完了之后还有6个零件
消费完了之后还有5个零件
消费完了之后还有4个零件
消费完了之后还有3个零件
消费完了之后还有2个零件
消费完了之后还有1个零件
消费完了之后还有0个零件
仓库里面没有库存了，请通知生产者去生产
生产完了之后有1个零件
生产完了之后有2个零件
生产完了之后有3个零件
生产完了之后有4个零件
生产完了之后有5个零件
生产完了之后有6个零件
生产完了之后有7个零件
生产完了之后有8个零件
生产完了之后有9个零件
生产完了之后有10个零件
消费完了之后还有9个零件
消费完了之后还有8个零件
消费完了之后还有7个零件
消费完了之后还有6个零件
消费完了之后还有5个零件
消费完了之后还有4个零件
消费完了之后还有3个零件
消费完了之后还有2个零件
消费完了之后还有1个零件
消费完了之后还有0个零件

之前有一次随机答应的很混乱的打印结果，之后就打不出来了很随机的。