JAVA-16.2-生产消费者模式

最新推荐文章于 2023-07-17 20:42:05 发布
最新推荐文章于 2023-07-17 20:42:05 发布
阅读量288 收藏
点赞数
分类专栏： JAVA学习笔记 文章标签： 线程 生产者消费者问题 等待唤醒机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30718113/article/details/72654344
版权

线程间通信(生产消费者问题)：不同类型线程针对同一个资源的操作
　　举例：1.系统不仅要卖票还要入票
　　　　　2.不仅要卖肉夹馍还要生产肉夹馍
这里写图片描述
今天主要讲解单生产单消费模式。
　　如果我们现在利用单生产单消费模式对学生进行设置姓名年龄，获取学生姓名年龄该怎么办呢？
这里写图片描述
首先，线程间通讯：
　　资源：Student（将学生作为资源进行操作）
　　设置数据线程：SetThread
　　获取数据线程：GetThread
　　测试类：StudentDemo
先考虑几个问题：
１.怎么保证资源唯一？（让设置和获取到的是同一资源，否则获取到的只能是null，0）
　　解决方法：当在不同的类中，需要使用同一个数据的时候，可以考虑将数据利用构造方法进行传参
2.数据重复问题？数据错乱问题？
　　解决方法：同步代码块或者同步方法都可以解决数据问题，加锁。
　　　　①设置线程和获取线程需要全部做一个限制，相当与两个线程都需要加锁
　　　　②设直线程和获取线程，加的锁必须是同一个，才可以保证数据安全

package com.edu_04;
//Student类
public class Student {
    String name;
    int age;
}
package com.edu_04;
//设置线程
public class SetThread implements Runnable{

    private Student s;
    private int x=0;

    public SetThread(Student s){
        this.s = s;
    }

    @Override
    public void run() {
        //给学生对象设置姓名和年龄
        //Student s = new Student();
        while (true) {
            synchronized (s) {
                if (x%2==0) {
                    s.name = "张三";
                    s.age = 50;
                }else {
                    s.name = "李四";
                    s.age = 35;
                }
                x++;
            }   
        }   
    }
}
package com.edu_04;
//获取线程
public class GetThread implements Runnable{
    private Student s;

    public GetThread(Student s){
        this.s = s;
    }
    @Override
    public void run() {
        //获取线程，获取学生对象的姓名和年龄
        //Student s = new Student();
        while (true) {
            synchronized (s) {  
                System.out.println(s.name+"--"+s.age);  
            }
        }
    }
}
package com.edu_04;
//测试类
public class StudentDemo {
    public static void main(String[] args) {
        //创建一个学生对象
        Student s = new Student();

        //创建设置和获取线程，并开启线程
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);

        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);

        //开启线程
        t1.start();
        t2.start();
    }
}

　　这样一来虽然保证了数据的安全性，资源唯一性，但是并没有实现礼让效果。怎么让数据变得和谐礼让呢？也就是说生产一个，获取一个，有理有序？
　　解决方法：使用等待唤醒机制改进，实现礼让效果
将上述问题全部解决之后，就得到了单生产单消费模式的整个流程，代码如下：
方式一：利用同步代码块

package com.edu_05;
//学生类
public class Student {
    String name;
    int age;
    boolean flag;//在这里可以作为对象的一个标记，如果是false说明该对象没有数据，如果是true说明该对象有数据
}
package com.edu_05;
//设置线程
public class SetThread implements Runnable{
    private Student s;
    private int x = 0;

    public SetThread(Student s){
        this.s = s;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                //判断该对象此时有没有数据
                if (s.flag) {
                    //等待
                    try {
                        s.wait();//设置线程等待，释放锁s
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                if (x%2==0) {
                    s.name = "张三";
                    s.age = 50;
                }else {
                    s.name = "李四";
                    s.age = 35;
                }
                x++;//x=1

                //此时对象有数据了
                s.flag = true;
                s.notify();//如果有等待的线程就唤醒，如果没有等待的线程，则没有任何效果
            }//在此时释放锁对象s
        }
    }
}
package com.edu_05;
//获取线程
public class GetThread implements Runnable{
    private Student s;

    public GetThread(Student s){
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                //判断对象有没有数据
                if (!s.flag) {
                    //等待设置线程给对象设置数据
                    try {
                        s.wait();//获取线程处于等待状态，释放锁对象s,在哪里跌倒在哪里爬起来
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                System.out.println(s.name+"--"+s.age);//张三--50
                                                      //李四--35
                                                      //张三--50

                //当获取线程从学生对象中获取了数据之后，我们就默认他已经没有数据了，此时我们应该
                //继续让设置线程继续给学生对象设置信息
                s.flag = false; 
                s.notify();
            }
        }
    }
}
package com.edu_05;
//测试
public class StudentDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();
        //创建设置线程和获取线程
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);

        //开启线程
        t1.start();
        t2.start();
    }
}
//张三--50
//李四--35
//张三--50

方式二：利用同步方法

package com.edu_06;
//学生类，并将设置获取方法封装
public class Student {
    //块编辑(alt+shift+a):在使用块编辑的时候，一定要将输入法切换到英文输入法，不然会出问题
    private String name;
    private int age;
    private boolean flag;//在这里可以作为对象的一个标记，如果是false说明该对象没有数据，如果是true说明该对象有数据

    //提供公共的方法设置信息
    public synchronized void setInfo(String name,int age){
        if (this.flag) {
            //等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        //没有值的话，在这里给对对象设置数据
        this.name = name;
        this.age = age;

        //更改标记，唤醒获取线程获取数据
        this.flag = true;
        this.notify();

    }
    //提供公共的方法获取信息
    public synchronized void getInfo(){
        if (!this.flag) {
            //没有值
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        //有数据，取数据
        System.out.println(this.name+"--"+this.age);

        //取完数据之后，就没有数据了
        this.flag = false;
        this.notify();
    }
}
package com.edu_06;
//设置线程
public class SetThread implements Runnable{
    private Student s;
    private int x = 0;

    public SetThread(Student s){
        this.s = s;
    }
    @Override
    public void run() {
        while (true) {
                if (x%2==0) {
                    s.setInfo("张三", 50);
                }else {
                    s.setInfo("李四", 35);
                }
                x++;//x=1
            }
    }
}
package com.edu_06;
//获取线程
public class GetThread implements Runnable{
    private Student s;

    public GetThread(Student s){
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            s.getInfo();
        }
    }
}
package com.edu_06;
//测试
public class StudentDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();
        //创建设置线程和获取线程
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);

        //开启线程
        t1.start();
        t2.start();
    }
}
Java--常用源码--生产者-消费者模式
似水流年
06-16 420
/** * 模拟生产者-消费者关系 * @author 似水流年 * */ public class Test { public static void main(String[] args) { Warehouse w = new Warehouse(); Proudcer p = new Proudcer(w); Customer
什么鬼，面试官竟然让我用Redis实现一个消息队列！！？
HollisChuang's Blog
12-02 3797
GitHub 9.4k Star 的Java工程师成神之路 ，不来了解一下吗? GitHub 9.4k Star 的Java工程师成神之路 ，真的不来了解一下吗? GitHub 9.4k Star 的Java工程师成神之路 ，真的确定不来了解一下吗? 众所周知，redis是一个高性能的key-value数据库，在NoSQL数据库市场上，redis自己就占据了将近半壁江山，足以见到其强大之处。同时，...
Java线程实现Redis任务队列(生产者消费者)
B_TAEYANG的博客
10-20 1万+
注：接上篇IDEA整合Redis，本篇实现Redis的任务队列，Redis连接池具体配置看上篇。 一：写一个Jedis的工具类JedisUtil，将Jedis中的部分方法实现，代码如下: package com.wq.Util; import com.wq.RedisPool.RedisPool; import redis.clients.jedis.Jedis; import java.
Java Jedis操作Redis示例（二）——list 生产者/消费者模式实现消息队列
Invoker's Tower
09-08 1万+
转载：http://www.cnblogs.com/huangxincheng/p/4970231.html 转载：http://www.cnblogs.com/stephen-liu74/archive/2012/02/14/2351859.html 转载：http://www.cnblogs.com/liuling/p/2014-4-19-04.html 转载：http://www.cn
Java --- 云尚优选项目
qq_46093575的博客
07-09 2667
vue : 无法加载文件 D:\tools\nodejs\node_global\vue.ps1。未对文件 D:\tools\nodejs\node_global\vue.ps1 进行数字签名。执行策略的详细信息，请参阅 https:/go.microsoft.com/fwlink/?解决办法：以管理员的方式运行即可。service接口实现类。service实现类层。controller层。controller层。service实现类。controller层。service实现类。controller层。
JAVA-1
明耀的博客
02-17 350
1 接口服务数据被劫包如何防止数据恶意提交 1.1:防篡改 客户端提交请求之前，先对自己请求的参数全部进行拼接加密得到一个加密字符串sign请求参数加上sign，然后再发送给服务器服务器将参数获取后也进行相同的拼接加密得到自己的sign比较与客户端发来的sign是否相同不相同则是被第三方修改过的，拒绝执行 关键： 第三方不知道加密方式和请求参数拼接规则，而客户端与服务器是知道的，因此第三方不知道修改参数后如何...
Java-高级技术(二)
热门推荐
Chovy_pyc的博客
04-22 1万+
Java 高级技术入门篇章二，篇幅比较大，后续会对文章内容进行拆分。
Java-JUC并发编程
AL ZN的博客
07-04 306
Java-JUC并发编程 学习视频： B站 狂神说java –【狂神说Java】JUC并发编程最新版通俗易懂_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili 1.什么是JUC JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。 java.util工具包。 业务：对于我们原来实现多线程的代码，实现三种接口， Thread、Runnable、Callable 三种创建线程的方式。 普通的线程代码 ：Thread。而Runnable接口，是要将实现Runnable接口的 r
从头认识java-目录
raylee2007的专栏
10-19 1万+
第一章 对象 1.1 编程语言抽象过程以及java的基础特性 1.2 对象-服务提供者 1.3 隐藏具体实现 1.4 复用代码 1.4 复用代码 1.5 继承（1） 1.5 继承（2）
动力节点RocketMQ视频笔记第二章RocketMQ与重复消费
f5465245的博客
05-11 851
RocketMQ提供了发送多种发送消息的模式，例如同步消息，异步消息，顺序消息，延迟消息，事务消息等，我们一一学习。
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 912
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
【大数据】-- Flink 1.16.0 发布
欢迎来到我的博客，一起探索代码里的世界！
03-01 393
flink 1.16.0 发布说明
设计模式——行为型模式
我姓弓长那个张的博客
07-09 955
行为型模式 行为型模式主要是用于描述类或者对象是怎样交互和怎样分配职责的。它涉及到算法和对象间的职责分配，不仅描述对象或者类的模式，还描述了他们之间的通信方式，它将你的注意力从控制流转移到了对象间的关系上来。行为型类模式采用继承机制在类间分派行为，而行为型对象模式使用对象复合而不是继承。它主要包括以下11种设计模式：职责链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式。 十二、职责链模式 避免请求发送者与接收者耦合在一起，让多个对象
Java基础
最新发布
qq_53466247的博客
07-17 6094
20世纪90年代，单片式计算机系统诞生，单片式计算机系统不仅廉价，而且功能强大，使用它可以大幅度提升消费性电子产品的智能化程度SUN公司为了抢占市场先机，在1991年成立了一个由詹姆斯·高斯林（James Gosling）领导，名为“Green”项目小组，目的是开发一种能够在各种消费性电子产品上运行的程序架构那么使用何种编程语言来设计，是项目小组头疼的事。
JAVA-8-常用API
喵喵的博客
04-24 6209
常用API讲解，主要有：基本数据类型包装类、Math类、Object类、Scanner类、Random类、System类、Date类、DateFomat类以及Calendar类......
JAVA-17.2-集合、IO流之综合演练
喵喵的博客
05-24 1977
本节主要进行了集合、IO流的综合演练，将知识融汇贯通
JAVA-21-JDBC讲解，Driver、Connection、Statement、PreparedStatement、CallableStatement、ResultSet
喵喵的博客
06-07 1878
之前操作mysql数据库： 1）使用mysql客户端工具 2）使用客户端连接mysql服务器 3）发送sql语句到mysql服务器，执行 那么什么是JDBC呢？ 使用java程序发送sql语句到数据库服务器端执行，这就用到了JDBC技术！jdbc是Oracle-Sun公司设计的一套专门用于java程序操作数据库的接口。
JAVA-2.4-鸡兔同笼
喵喵的博客
04-12 1130
趣味思考 　　鸡兔同笼，共有head个头，foot个脚，问鸡、兔各多少只？ 　　分析：鸡的头数*2=鸡的脚数 　　　　　兔的头数*2*2=兔的脚数 　　那么，脚的总数-头的总数*2=？？？显然，等于的是兔子比鸡多的脚数，而一只兔比一只鸡多了2只脚，所以兔子数是（脚的总数-头的总数*2）/2，问题迎刃而解。代码如下：package thinking;import java.util.Scann
JAVA-5-String类和StringBuffer类、二维数组、形参、冒泡排序及选择排序、Arrays数组工具类
喵喵的博客
04-11 1070
本节主要练习String类和StringBuffer类，讲解二维数组、形参、冒泡排序及选择排序、Arrays数组工具类
算法导论第16章16.2-5
05-23
算法导论第16章16.2-5题目描述： 证明：在所有的用于求解单源最短路径问题的算法中，Bellman-Ford算法是唯一一个能够处理权值可以是负数的图的算法。 证明如下： 首先，给定一个图G和一个源节点s，我们假设该图G...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值