【JavaSE】多线程之生产者与消费者模型

最新推荐文章于 2021-11-26 14:36:04 发布
最新推荐文章于 2021-11-26 14:36:04 发布
阅读量160 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gx123456sh/article/details/86775215
版权

wait（）与noyify（）用于同步代码块或同步方法必须是内建锁

1. wait（）—痴汉方法（运行态回阻塞态）

wait（）就是使线程停止运行，会释放对象锁。

I.wait（）方法会使当前线程调用该方法后进行等待，并且将该线程置入锁对象的等待队列中，直到接到通知或被中断为止。

II.wait（）方法只能在同步方法或同步代码块中调用，如果调用wait（）时没有适当的锁，会抛出异常。

III.wait（）方法执行后，当前线程释放锁，其他线程可以竞争该锁。

wait（）之后的线程继续执行有两种方法：

I.调用该对象的notify（）方法唤醒等待线程。

II.线程等待时调用interrupt（）中断该线程。

wait（long time）：如果到了预计时间还未被唤醒，线程将继续执行。

class MyThread implements Runnable{
    private Object object = new Object();
    @Override
    public void run() {
        synchronized (object){
            System.out.println("wait方法开始...");
            try {
                object.wait(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("wait方法结束...");
        }
    }
}
public class Test2{
    public static void main(String[] args) throws Exception {
        MyThread myThread = new MyThread();
        Thread thread = new Thread(myThread);
        thread.start();
    }
}

2.notify（）

I.notify（）方法也必须在同步方法或同步代码块中调用，用来唤醒等待在该对象上的线程。如果有多个线程等待，则任意挑选一个线程唤醒。

II.nitify（）方法执行后，唤醒线程不会立即释放对象锁，要等待唤醒线程全部执行完毕后才释放对象锁。

例：唤醒线程全部执行完毕后才会释放对象锁 

class MyThread implements Runnable{
    //锁定对象
    private Object object;
    private boolean flag;

    public MyThread(Object object,boolean flag) {
        this.object = object;
        this.flag = flag;
    }
    public void waitMethod(){
        synchronized (object){
            System.out.println("wait方法开始..."+Thread.currentThread().getName());
            try {
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("wait方法结束..."+Thread.currentThread().getName());
        }
    }
    public void notifyMethod(){
        synchronized (object){
            System.out.println("notify方法开始..."+Thread.currentThread().getName());
            //不会立即释放对象锁，要等notifyMethod方法执行完才会释放
            object.notify();
            System.out.println("notify方法结束..."+Thread.currentThread().getName());
        }
    }
    @Override
    public void run() {
        if(flag){
            this.waitMethod();
        }else{
            this.notifyMethod();
        }
    }
}

public class Test1{
    public static void main(String[] args) {
        Object object = new Object();
        MyThread waitMethod = new MyThread(object,true);
        MyThread notifyMethod = new MyThread(object,false);
        Thread thread1 = new Thread(waitMethod,"等待线程");
        Thread thread2 = new Thread(notifyMethod,"唤醒线程");
        thread1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
    }
}

例：多个等待线程，则随意挑选一个唤醒 

class MyThread implements Runnable{
    //锁定对象
    private Object object;
    private boolean flag;

    public MyThread(Object object,boolean flag) {
        this.object = object;
        this.flag = flag;
    }
    public void waitMethod(){
        synchronized (object){
            System.out.println("wait方法开始..."+Thread.currentThread().getName());
            try {
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("wait方法结束..."+Thread.currentThread().getName());
        }
    }
    public void notifyMethod(){
        synchronized (object){
            System.out.println("notify方法开始..."+Thread.currentThread().getName());
            object.notify();
            System.out.println("notify方法结束..."+Thread.currentThread().getName());
        }
    }
    @Override
    public void run() {
        if(flag){
            this.waitMethod();
        }else{
            this.notifyMethod();
        }
    }
}
public class Test2{
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        MyThread waitMethod = new MyThread(object,true);
        MyThread notifyMethod = new MyThread(object,false);
        for(int i=0; i<5; i++){
            Thread threadi = new Thread(waitMethod,"等待线程"+i);
            threadi.start();
        }
        Thread.sleep(1000);
        Thread thread = new Thread(notifyMethod,"唤醒线程");
        thread.start();
    }
}

3.notifyAll（）

唤醒所有在该对象上等待的线程。

class MyThread implements Runnable{
    //锁定对象
    private Object object;
    private boolean flag;

    public MyThread(Object object,boolean flag) {
        this.object = object;
        this.flag = flag;
    }
    public void waitMethod(){
        synchronized (object){
            System.out.println("wait方法开始..."+Thread.currentThread().getName());
            try {
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("wait方法结束..."+Thread.currentThread().getName());
        }
    }
    public void notifyMethod(){
        synchronized (object){
            System.out.println("notify方法开始..."+Thread.currentThread().getName());
            object.notifyAll();
            System.out.println("notify方法结束..."+Thread.currentThread().getName());
        }
    }
    @Override
    public void run() {
        if(flag){
            this.waitMethod();
        }else{
            this.notifyMethod();
        }
    }
}
public class Test1{
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        MyThread waitMethod = new MyThread(object,true);
        MyThread notifyMethod = new MyThread(object,false);
        for(int i=0; i<10; i++){
            Thread threadi = new Thread(waitMethod,"等待线程"+i);
            threadi.start();
        }
        Thread.sleep(1000);
        Thread thread = new Thread(notifyMethod,"唤醒线程");
        thread.start();
    }
}

4.线程阻塞

1.调用sleep（）方法，主动放弃占有的CPU，不会释放对象锁

2.调用阻塞式IO方法（read（）、write（）），在该方法返回前，线程阻塞。

3.线程试图获取一个monitor，但该monitor被其他线程所持有导致阻塞。

4.线程等待某个通知，即调用wait（），释放对象锁

5.调用线程suspend（），将线程挂起，容易导致死锁，已被废弃。

5.monitor的两个队列

每个monitor都有两个队列，一个称为同步队列，一个称为等待队列。

同步队列中存放了因为竞争monitor失败导致阻塞的线程，这些线程等待CPU调度再次竞争锁。

等待队列中存放因为调用wait（）导致线程等待的线程，唤醒后进入同步队列竞争锁。

class Goods{
    private String goodsName;
    private int count;
    //生产商品方法
    public synchronized void set(String goodsName){
        if(count>0){
            System.out.println("商品还有库存~");
            try {
                //等待消费者消费
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.goodsName = goodsName;
        count++;
        System.out.println(Thread.currentThread().getName()+"生产"+goodsName+toString());
        //唤醒等待消费的线程
        notify();
    }
    //消费商品方法
    public synchronized void get(){
        if(count == 0){
            System.out.println("商品已卖完~");
            try {
                //等待商品生产
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        System.out.println(Thread.currentThread().getName()+"消费"+goodsName+toString());
        //唤醒生产者继续生产商品
        notify();
    }

    @Override
    public String toString() {
        return " count = "+count;
    }
}

class Consumer implements Runnable{
    private Goods goods;
    public Consumer(Goods goods) {
        this.goods = goods;
    }
    @Override
    public void run() {
        goods.get();
    }
}
class Producer implements Runnable{
    private Goods goods;
    public Producer(Goods goods) {
        this.goods = goods;
    }
    @Override
    public void run() {
        goods.set("一套口红");
    }
}
public class Test2{
    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),"消费者");
        thread2.start();
        thread1.start();
    }
}

例：多生产多消费：

class Goods{
    private String goodsName;
    private int count;
    //生产商品方法
    public synchronized void set(String goodsName){
        while(count>0){
            System.out.println("商品还有库存~");
            try {
                //等待消费者消费
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.goodsName = goodsName;
        count++;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"生产"+goodsName+toString());
        //唤醒等待消费的线程
        notifyAll();
    }
    //消费商品方法
    public synchronized void get(){
        //不断判断执行条件
        while(count == 0){
            System.out.println("商品已卖完~");
            try {
                //等待商品生产
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.count--;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"消费"+goodsName+toString());
        //唤醒生产者继续生产商品
        notifyAll();
    }

    @Override
    public String toString() {
        return " count = "+count;
    }
}

class Consumer implements Runnable{
    private Goods goods;
    public Consumer(Goods goods) {
        this.goods = goods;
    }
    @Override
    public void run() {
        while(true){
            goods.get();
        }
    }
}
class Producer implements Runnable{
    private Goods goods;
    public Producer(Goods goods) {
        this.goods = goods;
    }
    @Override
    public void run() {
        while(true){
            goods.set("一套口红");
        }
    }
}
public class Test2{
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods();
        //存储多个生产、消费者线程
        List<Thread> list = new ArrayList<>();
        //10个消费者线程
        for(int i=0; i<10; i++){
            Thread thread = new Thread(new Consumer(goods),"消费者"+i);
            list.add(thread);
        }
        //5个生产者线程
        for(int i=0; i<5; i++){
            Thread thread = new Thread(new Producer(goods),"生产者"+i);
            list.add(thread);
        }
        for(Thread thread : list){
            thread.start();
        }
    }
}
class Goods{
    private String goodsName;
    private int count;

    public int getCount() {
        return count;
    }

    //生产商品方法
    public synchronized void set(String goodsName){
        this.goodsName = goodsName;
        count++;
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"生产"+goodsName+toString());
        //唤醒等待消费的线程
        notifyAll();
    }
    //消费商品方法
    public synchronized void get(){
        //不断判断执行条件
        while(count == 0){
            System.out.println("商品已卖完~");
            try {
                //等待商品生产
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.count--;
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"消费"+goodsName+toString());
        //唤醒生产者继续生产商品
        notifyAll();
    }

    @Override
    public String toString() {
        return " count = "+count;
    }
}

class Consumer implements Runnable{
    private Goods goods;
    public Consumer(Goods goods) {
        this.goods = goods;
    }
    @Override
    public void run() {
        while(true){
            goods.get();
        }
    }
}
class Producer implements Runnable{
    private Goods goods;
    public Producer(Goods goods) {
        this.goods = goods;
    }
    @Override
    public void run() {
        while(this.goods.getCount() < 200){
            goods.set("一套口红");
        }
    }
}
public class Test2{
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods();
        //存储多个生产、消费者线程
        List<Thread> list = new ArrayList<>();
        //10个消费者线程
        for(int i=0; i<10; i++){
            Thread thread = new Thread(new Consumer(goods),"消费者"+i);
            list.add(thread);
        }
        //5个生产者线程
        for(int i=0; i<5; i++){
            Thread thread = new Thread(new Producer(goods),"生产者"+i);
            list.add(thread);
        }
        for(Thread thread : list){
            thread.start();
        }
    }
}

 

gx1500291
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java多线程中的生产者消费者模型
刘勇的专栏
06-10 952
本文利用Java程序，实现一个多线程中的经典问题：生产者-消费者。 首先定义一个Buffer 类，生产者向这个Buffer里放产品（泛型定义），消费者从这个Buffer里取产品。如果Buffer满了，生产者等待；如果Buffer空了，消费者等待。 在主程序里，把Buffer的大小设置为10，启动了3个生产者，2个消费者，生产者生产一个产品需要1秒，消费者消费一个产品也需要一秒，运行30秒后，主
java多线程——生产者与消费者模型
L04593的博客
08-30 274
生产者与消费者 生产者与消费者模型 1.一个生产者一个消费者 步骤： 1.让生产者线程和消费者线程 共同操作同一个手机对象(资源) 2.让两个产品来回切换（目的是放大第一个步骤的问题）加锁，防止脏数据的出现 3.生产一个消费一个 代码实现： package com.dream.producer_consumer01_type01; public class Test01 { public static void main(String[] args) { Phone phone = new
多线程4
一个小白
09-04 201
10.8.生产与消费模型 实际生活中，需要操作共享的某个资源（水池），但是对这个共享资源的操作方式不同（部分是注水[生产]、部分是抽水[消费]）。把这种现象我们可以称为生产和消费模型。 生产：它可以采用部分线程进行模拟。多个线程同时给水池中注水。 消费：它可以采用部分线程进行模拟。多个线程同时从水池中抽水。 对资源的不同的操作方式，每种方式都可以让部分的线程去负责。多个不同的线程，他们对相同的资源（超市、水池等）操作方式不一致。 这个时候我们不能使用一个run方法对线程的任务进行封装。所以这里就需要定义不同
多线程之生产消费模型，多线程知识
weixin_30306905的博客
07-04 152
目录 进程： 生产者，消费者模型 1. 要解决什么问题？ 2. 解决办法：在生产者和消费者之间加入队列 线程 1. 什么是线程 2. 进程与线程的区别 3. 为什么用线程 4. 如何...
多线程设计模式:生产者-消费者
念念不忘，必有回响
09-03 2882
生产者，消费者：就好比厨师和食客，我们来看代码理解一下 https://www.cnblogs.com/xiaoxi/p/7910868.html https://www.jianshu.com/p/71a5089afe13
三种方式实现生产者-消费者模型
Sicimike的博客
11-17 4219
前言 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该...
Linux多线程——生产者消费者模型
weixin_57023347的博客
09-24 3781
一.生产者消费者模型 1.1 什么是生成者消费者模型 一个进程中的线程有两种角色，一种是生产者，一种是消费者。生产者为消费者提供任务，消费者拿到任务，解决任务。在生成者和消费者之间还有一个"交易场所"，是一个内存块。生成者线程将任务放到内存块中，消费者线程在内存块中拿任务。当内存块数据达到一高水位线时，生产者会进行等待，唤醒消费者拿任务，当内存块数据达到一低水位线时，消费者会等待，并且唤醒生产者生产任务。 生成者，消费者存在着3种关系。生产者和生产者之间......
JavaSE多线程
09-15
JavaSE的多线程特性是其强大的功能之一，它允许开发者编写能够同时处理多个任务的程序，从而提高程序的效率和响应性。在Java中，线程是程序执行的最小单位，而进程则是资源分配的基本单位。每个Java应用程序至少有一...
JavaSE之多线程实战视频课程
06-09
课程可能还会涵盖线程间的通信，如生产者消费者模型、哲学家就餐问题等经典示例，以及如何使用`BlockingQueue`进行高效且安全的数据交换。此外，线程池（ThreadPoolExecutor）的使用也是多线程实战中的重要部分，它...
javaSE多线程的案例源代码
04-01
源代码可能展示了生产者消费者模型或其他线程协作模式，如哲学家就餐问题的解决方案。 通过分析和学习这些源代码案例，开发者可以更深入地理解Java多线程的原理和实践，从而编写出更加健壮、高效的并发程序。对于...
java 多线程生产者消费者模型demo
03-31
java 多线程生产者消费者模型demo
javaSE代码实例
06-21
16.4.5　“生产者-消费者”案例的实际运行　365 16.4.6　notify方法的使用　366 16.4.7　同步的语句块　367 16.4.8　线程的死锁　369 16.4.9　防止错误的使用wait、notify、notifyAll方法　371 16.5　获取当前正在...
iChat ...另一个服务器/客户端模型...
04-08
2. **多线程**：服务器端可能需要处理多个并发的客户端连接，因此会涉及到线程的创建和管理。 3. **数据序列化和反序列化**：在网络间传输对象时，可能需要将对象转换为字节流，然后在接收端再还原。 4. **事件驱动...
Java多线程之生产消费模型
qq_41359998的博客
08-09 224
生产消费模型 所谓生产消费模型，是通过一个容器来解决生产者和消费者的强耦合问题。通俗的讲，就是生产者不断的生产， 消费之也在不断消费，消费者消费的产品是生产者生产的，这就必然存在一个中间的容器，我们可以把这个容器 想象成一个仓库，当仓库没有满的时候，生产者生产产品，当仓库满了的时候，生产者不能继续生产产品，而需 处于等待状态。当仓库不为空的时候，消费者可以消费产品，当仓库为空的时候，消费者不能再消费产品，而应 处于等待状态。这样不断循环，在这个过程中，生产者和消费者是不直接杰出的，所谓的仓库其实就是一个阻塞
Java中notify与wait
weixin_42087159的博客
12-01 150
Java中api对noyify以及wait的解释如下。 public final void notify()唤醒正在等待对象监视器的单个线程。 如果任何线程正在等待这个对象，其中一个被选择被唤醒。 选择是任意的，并且由实施的判断发生。 线程通过调用wait方法之一等待对象的监视器。 唤醒的线程将无法继续，直到当前线程放弃此对象上的锁定为止。 唤醒的线程将以通常的方式与任何其他线程竞争，这些线程可能...
JAVA多线程之生产者消费者模型
热门推荐
L_R
02-21 2万+
生产者消费者模型 所谓的生产者消费者模型，是通过一个容器来解决生产者和消费者的强耦合问题。通俗的讲，就是生产者在不断的生产，消费者也在不断的消费，可是消费者消费的产品是生产者生产的，这就必然存在一个中间容器，我们可以把这个容器想象成是一个货架，当货架空的时候，生产者要生产产品，此时消费者在等待生产者往货架上生产产品，而当货架满的时候，消费者可以从货架上拿走商品，生产者此时等待货架的空位，这样不断...
生产者消费者
love081300的博客
11-26 467
华工计算机辅修OS的实验二的问题1，不让用Python写 不过还是写了~~~ import threading import time import random #假设初始时无货物，货物架大小为30 n=30 empty,full,mutex=threading.Semaphore(30),threading.Semaphore(0),threading.Semaphore(1) def producer(i,goods): while(1): empty.acquire()
【JavaSE】多线程中典型的生产者与消费者模型
eternal_01的博客
07-10 258
生产者和消费者模型 生产者和消费者模式是通过一个容器来解决生产者和消费者之间的强耦合问题，彼此之间不接直接通话，而是通过阻塞队列来进行通话，所以生产者生产完数据不需要等待消费者，直接扔给阻塞队列，消费者不直接找生产者要，直接从阻塞队列里面取，这个阻塞队列就是用来给生产者和消费者解耦的，之前在前面写的工厂模式，模板模式，都是存在第三方 **下面模拟一个简单的商品生产者和消费者** ...
一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3.编程 找出1000以内的所有完数。
gx123456sh的博客
11-03 2万+
        一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3.编程 找出1000以内的所有完数。 思路：首先求出一个数的所有因子            在判断这个数的所有因子之和与它本身是否相等 public class test{ public static void main(String[] args){ int i,j; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gx1500291

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值