day20Java-Thread-多线程中生产者和消费者

最新推荐文章于 2022-03-11 21:14:28 发布
最新推荐文章于 2022-03-11 21:14:28 发布
阅读量179 收藏
点赞数
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40332952/article/details/105306390
版权
博客
Java-(高级)

文章目录

多线程生产者和消费者

前面已经写过电影票程序,不是特别的符合实际情况。

多线程生产者和消费者:
就是不同种类的线程对同一个资源的操作。

自己对Java等待唤醒机制总结:
之前买电影票的线程只有一个卖票线程,创建多个线程对象去执行它。出现了线程安全问题可以使用同步来解决。

但是现在是不同种类的线程对同一个资源的操作。也可以使用同步来解决线程安全问题，线程安全问题解决了，但是打印的结果不是很符合实际情况，如果让不同种类的线程更符合实际情况，可以使用Java的等待唤醒机制。

线程通信问题：
		不同种类的线程间针对同一个资源的操作。

在这里插入图片描述

多线程生产者消费者代码版本1

代码演示
生产者消费者测试

public class StudnetThreadDemo {
    public static void main(String[] args) {
        //创建一个生产者消费者共享的对象
        Student s = new Student();
        
        //创建生产者线程对象
        SetThread st = new SetThread(s);
        //创建消费者线程对象
        GetThread gt = new GetThread(s);

        //启动线程
        st.start();
        gt.start();
    }
}

生产者

public class SetThread extends Thread {
    private Student s;

    public SetThread(Student s) {
        this.s = s;
    }
    @Override
    public void run() {
        int count = 0;
        while (true) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count % 2 == 0) {
                //Student s = new Student();
                s.name = "格雷福斯";
                s.age = 60;
            } else {
                s.name = "至高之拳";
                s.age = 30;
            }
            count++;
        }
    }
}

消费者

public class GetThread extends Thread {
    private Student s;

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

    @Override
    public void run() {
        //这里不能这样创建对象,那样就是各使用各的。
        //Student s = new Student();
        while (true) {
            /*try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            System.out.println(s.name + "-" + s.age);
        }
    }
}

实体类

public class Student {
    public String name;
    public int age;
}

结果:我只列出来了有问题的

斯-60
格雷福斯-3
至高之拳-60
格雷福斯-60
格雷福斯-60
格雷福斯-60
格雷福斯-60
格雷福斯-60
格雷福斯-60
多线程生产者消费者代码版本2-同步解决问题
分析：
		资源类：Student	
		设置学生数据:SetThread(生产者)
		获取学生数据：GetThread(消费者)
		测试类:StudnetThreadDemo 

问题1:按照思路写代码，发现数据每次都是:null---0
原因:我们在每个线程中都创建了新的资源,而我们要求的时候设置和获取线程的资源应该是同一个
如何实现呢?
		在外界把这个数据创建出来，通过构造方法传递给其他的类。

问题2:为了效果更好一些,我加入的循环和判断,给出不同的值,但是出现了新的问题。
	A:相同的数据出现了多次
			原因：CPU一点时间片执行权，足够线程执行很多次了。
	B:姓名和年龄不匹配
			原因：因为多线程运行的随机性导致的

线程安全问题?
			A:是否是多线程环境?		是
			B:是否有共享数据? 	是 	Student
			C:是否有多条语句操作共享数据? 是	

解决方案：
 		加锁。

注意：
  			A:不同种类的线程都要加锁。
  				如果只有生产者一种类型线程加锁,还是会出现上面一样的问题。
  			B:不同种类的线程加的锁必须是同一把。
  				如果不同类型线程锁不同,各自锁各自的,也会出现上面一样的问题,那毫无意义。
加锁后:
	实现生产者在生产的时候,消费者不能消费不能消费(生产者那边已经把锁锁住了),消费者在消费的时候,生产者那边不能生产(消费者那边已经把锁锁住了)
	加锁后也就是把年龄和姓名不匹配的问题解决了,但是没有解决同一个数据出现多次。
	数据安全了。

代码演示
生产者消费者测试

public class StudnetThreadDemo {
    public static void main(String[] args) {
        //创建一个生产者消费者共享的对象
        Student s = new Student();

        //创建生产者线程对象
        SetThread st = new SetThread(s);
        //创建消费者线程对象
        GetThread gt = new GetThread(s);

        //启动线程
        st.start();
        gt.start();
    }
}

生产者

public class SetThread extends Thread {
    private Student s;

    public SetThread(Student s) {
        this.s = s;
    }
	int count = 0;
    @Override
    public void run() {
       
        while (true) {
            synchronized (s) {
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (count % 2 == 0) {
                    //Student s = new Student();
                    s.name = "格雷福斯"; //不加同步刚执行到这里,就被其他线程抢到执行权了,上面一次内存中的值可能是name=至高之
                    //拳,age=30,如果这时候输出值也就name="格雷福斯",age=30。 					 		    
                    s.age = 60;
                } else {
                    s.name = "至高之拳";//不加同步刚执行到这里,就被其他线程抢到执行权了,上一次内存中的值可能是name=格雷福斯,age=60
                    //如果这时候输出值也就是name=至高之拳,age=60;
                    s.age = 30;
                }
                count++;
            }
        }
    }
}

消费者

public class GetThread extends Thread {
    private Student s;

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

    @Override
    public void run() {
        //这里不能这样创建对象,那样就是各使用各的。
        //Student s = new Student();
        while (true) {
            synchronized (s) {
            /*try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
                System.out.println(s.name + "-" + s.age);
            }
        }
    }
}

实体类

public class Student {
    public String name;
    public int age;
}

结果:

格雷福斯-60
格雷福斯-60
格雷福斯-60
格雷福斯-60
格雷福斯-60
格雷福斯-60
格雷福斯-60
格雷福斯-60
至高之拳-30
至高之拳-30
至高之拳-30
至高之拳-30
至高之拳-30
至高之拳-30
多线程生产者消费者代码版本3-等待唤醒机制解决问题
上面其实已经解决数据安全问题了,但是呢?数据输出相同的数据都是打印一大片。觉得不是很好看,想依次打印出来。
同步能解决线程安全问题。但是解决不了那种很理性的输出数据。

如何实现呢?
为了满足这样需求Java就提供了等待唤醒机制解决。
等待和唤醒:
		Object中提供了3个方法:	
					wait():等待。
					notify:唤醒单个线程。
					notify:唤醒所有线程。

为什么这些方法不定义在Thread类中呢?
 			这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
  			所以，这些方法必须定义在Object类中。

等待唤醒机制思路图解
在这里插入图片描述

代码演示
生产者消费者测试

public class StudnetThreadDemo {
    public static void main(String[] args) {
        //创建一个生产者消费者共享的对象
        Student s = new Student();

        //创建生产者线程对象
        SetThread st = new SetThread(s);
        //创建消费者线程对象
        GetThread gt = new GetThread(s);

        //启动线程
        st.start();
        gt.start();
    }
}

生产者

public class SetThread extends Thread {
    private Student s;

    public SetThread(Student s) {
        this.s = s;
    }
	int count = 0;
    @Override
    @SuppressWarnings("all")
    //生产者
    public void run() {   
        while (true) {
            synchronized (s) {
                //如果有数据就等待,没有数据就创建
                if(s.flag){
                    try {
                        s.wait(); //满足判断条件st等待,立即释放锁。st等待的情况下,只能gt抢到执行权。
                        //注意:醒来是从这里醒来的。
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (count % 2 == 0) {
                    //Student s = new Student();
                    s.name = "格雷福斯";
                    s.age = 60;
                } else {
                    s.name = "至高之拳";
                    s.age = 30;
                }
                count++;
                //到这里说明数据已经生产好了,修改标记
                s.flag =true;
                //唤醒线程
                s.notify(); //唤醒线程,唤醒线程后不会立马执行。在抢CPU执行权。

                //st抢到或者gt抢到
                //情况1:如果是st抢到cpu执行权,刚才已经生产好数据了,那就要等待了。

                //情况2:gt抢到cpu执行权那就从消费者的wait()中醒来,继续向下执行。
            }
        }
    }
}

消费者

public class GetThread extends Thread {
    private Student s;

    public GetThread(Student s) {
        this.s = s;
    }
    //消费者
    @Override
    public void run() {
        //这里不能这样创建对象,那样就是各使用各的。
        //Student s = new Student();
        while (true) {
            synchronized (s) {
                //如果有数据,就消费,没有就等待。
                if(!s.flag){
                    try {
                        s.wait();//满足判断条件gt等待,并立即释放锁。gt等待的情况下,只能st抢到执行权。
                        //注意:醒来是从这里醒来的。
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(s.name + "-" + s.age);
                //到这里说明已经消费完,修改标记
                s.flag = false;
                //唤醒线程
                s.notify();//唤醒线程,唤醒线程后不会立马执行。在抢CPU执行权。

                //st抢到或者gt抢到
                //情况1:如果gt抢到了cpu的执行权,数据已经消费完了,那就要等待了。

                //情况2:st抢到了cpu执行权那就从生产者wait()中醒来,继续向下执行。
            }
        }
    }
}

实体类

public class Student {
    public String name;
    public int age;
    public boolean flag; //定义一个标记,是否有学生,默认是false.没有数据
}

结果:

格雷福斯-60
至高之拳-30
格雷福斯-60
至高之拳-30
格雷福斯-60
至高之拳-30
格雷福斯-60
至高之拳-30
格雷福斯-60
至高之拳-30
格雷福斯-60
至高之拳-30

线程状态转换图
在这里插入图片描述

多线程生产者消费者代码版本4-代码优化

代码演示
生产者消费者测试

public class StudentDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s =  new Student();
        //创建线程对象
        SetThread st = new SetThread(s);
        GetThread gt=  new GetThread(s);

        //启动线程
        st.start();
        gt.start();
    }
}

生产者

public class SetThread extends Thread {
    private Student s;

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

    int count = 0;

    @Override
    public void run() {
        while (true) {
            if (count % 2 == 0) {
                s.setNameAge("格雷福斯", 60);
            } else {
                s.setNameAge("至高之拳", 30);
            }
            count++;
        }
    }
}

消费者

public class GetThread extends Thread {
    private Student s;

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

    @Override
    public void run() {
        while (true) {
            s.getNameAge();
        }
    }
}

实体类

public class Student {
    //实际开发中成员变量肯定是不能被外界访问的
    private String name;
    private int age;
    private boolean flag;

    public synchronized void setNameAge(String name, int age) {
        //如果数据存在就等待
        if (this.flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name;
        this.age = age;
        //修改标记
        this.flag = true;
        //唤醒线程
        this.notify();
    }

    public synchronized void getNameAge() {
        //如果没有数据就等待
        if (!this.flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(this.name + "-" + this.age);
        //修改标记
        this.flag = false;
        //唤醒线程
        this.notify();
    }
}

结果:

格雷福斯-60
至高之拳-30
格雷福斯-60
至高之拳-30
格雷福斯-60
至高之拳-30
格雷福斯-60
至高之拳-30
格雷福斯-60
至高之拳-30
格雷福斯-60
ginger_mr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Day 22多线程、线程通信、线程池和Lambda表达式
12-22
例如，生产者消费者模型中，生产者线程和消费者线程通过共享数据结构（如队列）来交互，生产者生产商品放入队列，消费者从队列中取出商品。为了保证数据的一致性，通常需要使用`wait()`和`notify()`进行同步控制，...
嵌入式实习-day5-线程
11-20
在此场景中，信号量用于协调生产者和消费者线程对共享资源的访问。具体来说： - 生产者线程每次生产一个产品前，会先尝试获取信号量。如果信号量的值大于0，则减少信号量并生产一个产品；否则，线程将阻塞直到...
Thread的生产者和消费者模式
K_122的博客
08-01 539
一，介绍                             生产者消费者模式，其实也是一种线程同步的机制，是利用线程间互斥的规则来达到，线程同步的，下面画个图来解释下这种机制                                    如下图：
Thread类之-生产者消费者模式
临窗，听雨声
08-29 295
为了避免死锁，我们引用生产者消费者模式，就像我要筷子的时候，你就把筷子给我，我吃一口，然后你要碗的时候，我就把碗给你，你再吃一口。 共享吃饭程序： 我吃的时候你把筷子给我，你吃的时候我把碗给你 public class CHIFAN { // 信号灯,为true 的时候我吃,你看,为false 的时候我看你吃 private boolean flag = true; /** ...
Java多线程Day11-多线程之生产者消费者
攻城狮Chova的博客
09-24 380
生产者消费者问题生产者消费者模型 生产者消费者模型 生产者消费者模型包括生产者,消费者,仓库,产品: 生产者在仓库未满时才能生产,仓库满时停止生产 消费者在仓库有产品时才能消费,仓库空时等待 当消费者发现仓库为空,没有产品可以消费时,通知生产者生产 生产者在生产出可以消费的产品时,通知等待的消费者消费 ...
Java多线程----消费者/生产者模型
weixin_44006265的博客
10-19 155
前言 生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。 /** * @description 生产者/消费者：生产者生产了产品，消费者才能消费产品 **/ public class Day63 { /** * product:1--有产品，0--没产品 */ static int product = 0;
Day65.练习4生产者消费者例题 -Java多线程
阿昌爱Java
10-08 218
生产者消费者例题 /** * 线程通信的应用: 经典例题: 生产者/消费者问题 * * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品， * 店员一次只能持有固定数量的产品(比如:20），如果生产者试图 生产更多的产品， * 店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产； * 如果店中没有产品了，店员会告诉消费者等一下， * 如果店中有产品了再通知消费者来取走产品。 * * 分析: * 1. 是否是多线程问题
【JAVA多线程】如何解决一个生产者与消费者问题
热门推荐
阳阳的博客
11-01 1万+
如何解决一个生产者与消费者问题 生产者与消费者问题是多线程同步的一个经典问题。生产者和消费者同时使用一块缓冲区，生产者生产商品放入缓冲区，消费者从缓冲区中取出商品。我们需要保证的是，当缓冲区满时，生产者不可生产商品；当缓冲区为空时，消费者不可取出商品。 下面介绍java中几种解决同步问题的方式 （1）wait()与notify()方法...
多线程 Java 生产者消费者
qq_45779316的博客
02-21 165
多线程 基本概念 程序：为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程：程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：它有自身的产生、存在和消亡。——生命周期 程序是静态的，进程是动态的。 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。 线程：进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个进程同时执行多个线程，就是支持多线程的。 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器，线程切换的开销
Java基础22 多线程之多生产者多消费者
Xs943的博客
03-11 1831
生产者消费者 包子案例 多个类（称为线程一类，线程二类） 需要一个共有的变量，即将这个变量封装为一个类（称为属性类）的属性，注意属性类的属性修饰符为public公共的，在测试类中new 这个属性类实例化为对象，然后将此对象作为参数传入需要的多个类（线程一，线程二）中，就可以实现共享对象的属性即变量，且多个类（线程一，线程二） 需要定义此对象（属性类）为私有变量，并提供有参构造 生产者线程和消费者线程要有共享对象，即将包子提升为类作为参数传入生产者线程和消费者线程，这个包子类就是共享的对象，就可以使用 syn
java5个生产者5个消费者_java多线程之--多的生产者与多个消费者
weixin_34587189的博客
03-02 236
package com.qianfeng.day22_Thread;/** 多个生产者和多个消费者，包子数量最多5个，给包子编号，要求随机消费*/public class Demo04 {public static void main(String[] args) {Produce04 p = new Produce04();Customer04 c = new Customer04();Thre...
java多线程
04-21
在`day23_Thread.rar`和`code.rar`中，可能包含了一些示例代码，例如实现生产者消费者模型、哲学家就餐问题、银行转账操作等，这些都是多线程编程的经典应用场景。通过分析和运行这些代码，你可以更好地理解上述理论...
day020-继承加强和设计模式代码和笔记.rar
03-15
将生产和消费分离（解耦），即创建对象和使用对象的功能分离，便于管理 缺点： 1.扩展性弱，如果添加了新的产品，则需要修改工厂方法 使用场景： 适用于产品数量较少，且不经常改变的情况 ...
Java学习路线：day19
01-20
生产者/消费者问题JDK5.0新增线程创建方式创建多线程的方式三：实现Callable接口使用线程池的好处创建多线程的方式四：使用线程池 原文：https://shimo.im/docs/KGCJKyrgG8rtXj3G/ 《第8章 多线程》 第8章
聚类算法-一种无监督学习方法.docx
最新发布
08-12
聚类算法是一种无监督学习方法，用于将数据集中的数据点自动分组到不同的类别中，这些类别也称为“簇”或“群”。聚类的目标是让同一簇内的数据点尽可能相似，而不同簇之间的数据点尽可能不相似。聚类算法广泛应用于多种领域，如数据挖掘、模式识别、图像分析、信息检索等。 聚类算法的基本概念 无监督学习：聚类算法不需要事先标记数据点的类别标签，而是根据数据本身的相似性来分组。 相似性度量：聚类算法依赖于某种相似性或距离度量来决定数据点之间的相似程度。常用的度量包括欧氏距离、曼哈顿距离等。 目标函数：大多数聚类算法都会尝试最小化某种目标函数，例如簇内的平方误差和（SSE）。 常见的聚类算法 K-Means K-Means 是一种原型聚类算法，它通过迭代地将数据点分配到最近的质心来形成簇，并重新计算每个簇的质心，直到质心不再显著变化为止。 在 Python 的 scikit-learn 库中，可以通过 KMeans 类实现 K-Means 聚类。 层次聚类 层次聚类构建一个树状图（称为树状图或 dendrogram），显示数据点是如何逐渐合并成簇的。 这种算法可以是凝聚型（自底向上）或分裂型（自顶向下）。
45ft集装箱模型3D图纸 STEP格式.zip
08-12
45ft集装箱模型3D图纸 STEP格式.zip
Spring Boot网吧管理系统.zip
08-12
该系统严格按照需求分析制作相关模块，并利用所学知识尽力完成，但是本人由于学识浅薄，无法真正做到让该程序可以投入市场使用，仅仅简单实现部分功能，希望日后还能改善。 本系统具有以下优点： 该系统具有较高的适用性，选用B/S结构，可以在绝大部分个人平台上使用该系统。 系统将用户权限进行划分，管理员，网管和会员都能看到及操作的信息不一样，三者具备不同的操作权限。 该系统操作界面简单明了，大部分人都可以正常使用。 但也存在以下问题需要改进： 运行时窗口不能被刷新，可以改进。 系统过于简单，显示的信息有限。。 不能添加多个管理员账号，如果可以则将利于发展网吧规模，便于网吧信息集中管理。 不能实时预约接待消息和网吧反馈建议，容易被忽视，不利于管理员服务客户。
微信小程序大作业 新闻小程序
08-12
微信小程序大作业 新闻小程序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值