Java生产与消费者模型---等待唤醒机制

于 2019-08-05 15:40:58 发布
阅读量215 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq940051592/article/details/98487093
版权
本文深入探讨了生产者与消费者模型在多线程环境中的应用，详细解释了如何使用wait(), notify() 和 notifyAll() 方法来实现线程间的同步与通信，通过具体代码示例展示了单生产单消费与多生产多消费场景。

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

生产者与消费者模型简介

生产者和消费者彼此之间不直接沟通，而通过阻塞队列来进行通讯，当生产者生产的商品不足时，生产者开始生产，消费者进行阻塞，当生产者生产充足的商品后，唤醒消费者，进行出售......所以生产者生产完数据之后不会等待消费者处理，直接唤醒阻塞队列中的所有线程，同时自身阻塞，消费者在消费完成后，同时唤醒阻塞队列中的所有线程，自身进行阻塞.......阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的能力

wait()方法

  • 方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法是用来将当前线程置入“预执行队列”中，并且wait()所在的代码处停止执行，知道接到通知或被中断为止
  • wait()只能在同步方法或同步代码块中调用，如果调用wait()时，没有适当的锁会抛出异常
  • wait()方法执行后，当前线程释放锁，线程与其它线程竞争重新获取锁

notify()方法

  • 方法notify()作用是使停止的线程继续运行
  • 方法notify()也要在同步方法或同步代码块中调用，该方法是用来通知那些可能等待该对象的对象锁的其他线程，对其发出通知notify，并使它们重新获取该对象的对象锁，如果有多个线程等待，线程规划器随机挑选一个呈wait状态的线程
  • 在notify()之后，当前对象不会马上释放对象锁，要等到执行notify()方法的线程将程序执行完，也就使退出同步代码块之后才会释放对象锁

notifyAll()方法

  • 同notify()方法，当时他可一次性唤醒阻塞队列所有的线程

注意：每个锁对象有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，一个线程被唤醒后，才会进入就绪队列，等待CPU的调度，一个线程被wait后，就会进入阻塞队列，等待下一次被唤醒，得到notify通知后只是从等待队列移出来。在移出来的时候，有可能不直接进入就绪队列直接拿到对象锁，但大多情况下是直接进入就绪队列

单生产单消费模型

商品类

package com.lin;

import org.omg.PortableServer.THREAD_POLICY_ID;

/**
 * Description:
 * Author:  llf
 * Created in 2019/8/5 14:06
 */
public class Goods {
    private String goodsName;
    private int count;

    public Goods() {

    }

    public synchronized void set(String goodsName) throws InterruptedException {
        //当生产者生产产品数量超过5个，则等待阻塞，释放对象锁，由消费者竞争锁
        if (this.count>5) {
            System.out.println("还有商品库存，等待消费者消费");
            wait();
        }
        this.goodsName=goodsName;
        this.count++;
        Thread.sleep(1000);
        System.out.println("生产"+toString());
        //唤醒消费者线程，此时已有商品
        notify();
    }

    public synchronized void get() throws InterruptedException {
        当没有商品买了，自身阻塞等待，释放对象锁，等待生产者生产出商品在竞争锁继续运行
        if (this.count==0) {
            System.out.println("商品已卖完，等待生产者生产");
            wait();
        }
        this.count=this.count-1;
        Thread.sleep(1000);
        System.out.println("消费"+toString());
        //唤醒生产者线程，此时可能会即将没有商品
        notify();
    }

    @Override
    public String toString() {
        return "Goods{" +
                "goodsName='" + goodsName + '\'' +
                ", count=" + count +
                '}';
    }
}

生产者

package com.lin;

/**
 * Description:
 * Author:  llf
 * Created in 2019/8/5 14:11
 */
public class Producer implements Runnable{
    private Goods goods;

    public Producer(Goods goods) {
        super();
        this.goods = goods;
    }

    @Override
    public void run() {
            try {
                this.goods.set("小黑瓶");
            } catch (InterruptedException e) {
                e.printStackTrace();
        }
    }
}

消费者

package com.lin;

/**
 * Description:
 * Author:  llf
 * Created in 2019/8/5 14:11
 */
public class Consumer implements Runnable{
    private Goods goods;

    public Consumer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
            try {
                this.goods.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    }
}

测试

package com.lin;

import java.util.ArrayList;
import java.util.List;

/**
 * Description:
 * Author:  llf
 * Created in 2019/8/5 14:17
 */
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Goods goods=new Goods();
        Thread thread1=new Thread(new Producer(goods),"生产者");
        Thread thread2=new Thread(new Consumer(goods),"消费者");
        thread1.start();
        thread2.start();
    }
}

程序运行结果

生产者生产Goods{goodsName='小黑瓶', count=1}
生产者生产Goods{goodsName='小黑瓶', count=2}
生产者生产Goods{goodsName='小黑瓶', count=3}
生产者生产Goods{goodsName='小黑瓶', count=4}
生产者生产Goods{goodsName='小黑瓶', count=5}
生产者生产Goods{goodsName='小黑瓶', count=6}
消费者消费Goods{goodsName='小黑瓶', count=5}
生产者生产Goods{goodsName='小黑瓶', count=6}
还有商品库存，等待消费者消费
消费者消费Goods{goodsName='小黑瓶', count=5}
消费者消费Goods{goodsName='小黑瓶', count=4}
消费者消费Goods{goodsName='小黑瓶', count=3}
消费者消费Goods{goodsName='小黑瓶', count=2}
生产者生产Goods{goodsName='小黑瓶', count=3}
消费者消费Goods{goodsName='小黑瓶', count=2}
消费者消费Goods{goodsName='小黑瓶', count=1}
消费者消费Goods{goodsName='小黑瓶', count=0}
商品已卖完，等待生产者生产

多生产者多消费者模型

商品类

package com.lin;


/**
 * Description:
 * Author:  llf
 * Created in 2019/8/5 14:06
 */
public class Goods {
    private String goodsName;
    private int count;

    public Goods() {

    }

    public synchronized void set(String goodsName) throws InterruptedException {
        //若此时商品已充足，不需生产，则循环阻塞所有生产者线程
        while (this.count>5) {
            System.out.println("还有商品库存，等待消费者消费");
            wait();
        }
        this.goodsName=goodsName;
        this.count++;
        Thread.sleep(1000);
        System.out.print(Thread.currentThread().getName());
        System.out.println("生产"+toString());
        //已生产商品，唤醒所有线程
        notifyAll();
    }

    public synchronized void get() throws InterruptedException {
        //已无商品可买，需要生产者生产，循环阻塞消费者线程
        while (this.count==0) {
            System.out.println("商品已卖完，等待生产者生产");
            wait();
        }
        this.count=this.count-1;
        Thread.sleep(1000);
        System.out.print(Thread.currentThread().getName());
        System.out.println("消费"+toString());
        //可能商品数量不足，唤醒所有线程
        notifyAll();
    }

    @Override
    public String toString() {
        return "Goods{" +
                "goodsName='" + goodsName + '\'' +
                ", count=" + count +
                '}';
    }
}

生产者

package com.lin;

/**
 * Description:
 * Author:  llf
 * Created in 2019/8/5 14:11
 */
public class Producer implements Runnable{
    private Goods goods;

    public Producer(Goods goods) {
        super();
        this.goods = goods;
    }

    @Override
    public void run() {
        while(true) {
            try {
                this.goods.set("小黑瓶");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者

package com.lin;

/**
 * Description:
 * Author:  llf
 * Created in 2019/8/5 14:11
 */
public class Consumer implements Runnable{
    private Goods goods;

    public Consumer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        while (true) {
            try {
                this.goods.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试类

package com.lin;

import java.util.ArrayList;
import java.util.List;

/**
 * Description:
 * Author:  llf
 * Created in 2019/8/5 14:17
 */
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Goods goods=new Goods();
        List<Thread> threadList=new ArrayList<Thread>();
        for (int i = 0; i <10 ; i++) {
            Thread thread1=new Thread(new Producer(goods),"生产者"+i);
            threadList.add(thread1);
        }
        for (int i = 0; i < 6; i++) {
            Thread thread2=new Thread(new Consumer(goods),"消费者"+i);
            threadList.add(thread2);
        }
        for (Thread thread:threadList) {
            thread.start();
        }
    }
}

运行结果

生产者0生产Goods{goodsName='小黑瓶', count=1}
生产者0生产Goods{goodsName='小黑瓶', count=2}
生产者0生产Goods{goodsName='小黑瓶', count=3}
生产者0生产Goods{goodsName='小黑瓶', count=4}
生产者0生产Goods{goodsName='小黑瓶', count=5}
生产者0生产Goods{goodsName='小黑瓶', count=6}
消费者5消费Goods{goodsName='小黑瓶', count=5}
消费者3消费Goods{goodsName='小黑瓶', count=4}
消费者3消费Goods{goodsName='小黑瓶', count=3}
消费者3消费Goods{goodsName='小黑瓶', count=2}
消费者3消费Goods{goodsName='小黑瓶', count=1}
消费者4消费Goods{goodsName='小黑瓶', count=0}
商品已卖完，等待生产者生产
商品已卖完，等待生产者生产
商品已卖完，等待生产者生产
商品已卖完，等待生产者生产
生产者9生产Goods{goodsName='小黑瓶', count=1}

 

qq940051592
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值