JavaSE——多线程部分案例之“车站卖票”、“生产者消费者模型”、“仓储模型”

最新推荐文章于 2024-01-05 22:54:18 发布
最新推荐文章于 2024-01-05 22:54:18 发布
阅读量429 收藏 2
点赞数 2
分类专栏： 雍某人的Java成神之路 文章标签： java 多线程
若非原创，请点转载，原创不易，盗文可耻。
本文链接：https://blog.csdn.net/yongzhongyang/article/details/119855285
版权

文章目录

文章目录

前言

我要光明正大地学习，然后惊艳所有人~~~

本次任务的内容是记录的我的三个案例，这三个案例很重要，其基础模型思想涉及到后面的项目开发中的许多设计思想，一定一定要弄懂它

提示：以下是本篇文章正文内容，下面案例可供参考

一、车站卖票的案例：

适用场景：多线程中不同但具有相同功能的线程来操纵共有的数据， 有票1000张。有三个售票窗口，并通过这三个售票窗口进行销售，销售完毕后就显示票已经卖完提示、

创建线程任务类（卖票的任务）


import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Task implements Runnable{

    private int ticket = 1000;//由于三个窗口都需要卖票，所以设为全局变量

    private Lock lock = new ReentrantLock();

    @Override
    public void run() {

        while(ticket > 0){
            lock.lock();
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + "正在销售第" + ticket + "张票");
                ticket--;
            }
            if(ticket <= 0){
                System.out.println(Thread.currentThread().getName() + "票已售完");
            }
            lock.unlock();
        }
    }
}

创建启动测试类


public class Test {

    public static void main(String[] args) {
        /**
         * 2.铁道部发布了一个售票任务，要求销售1000张票，要求有3个窗口来进行销售，
         * 请编写多线程程序来模拟这个效果
         窗口001正在销售第1000张票
         窗口001正在销售第999张票
         窗口002正在销售第998张票
         。。。
         窗口002正在销售第1张票

         问题1：三个窗口都卖了1000张票，一共卖了3000张
         出现原因：创建了三个售票任务
         解决方案：创建一个售票任务

         问题2：有些票卖了重票
         出现原因：票的输出语句输出后，还没有来得及做票的减减，就被其他线程抢到CPU资源了
         解决方案：票的输出语句 和 票的减减必须同时执行完毕后，才能被其他线程抢到CPU资源了 - 加锁

         问题3：出现负数
         出现原因： 票到了零界点（ticket=1），三个线程都进入循环中
         解决方案：锁中再判断一次

         */
        Task task = new Task();
        Thread t1 = new Thread(task, "窗口001");
        Thread t2 = new Thread(task, "窗口002");
        Thread t3 = new Thread(task, "窗口003");

        t1.start();
        t2.start();
        t3.start();
    }
}

二、“生产者”与“消费者”案例

适用场景：当不同功能的线程控制着同一个资源的时候使用，本次案例通过卖手机的方式来展示

案例一、一个“生产者”与“消费者”的情况下

创建一个手机实体类-----phone


public class Phone {
    private String brand;
    private  double price;
    public boolean isStore;

    public Phone() {
    }

    public Phone(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
    public boolean isStore(){
        return isStore;
    }
    public void setStore(boolean isStore){
        this.isStore=isStore;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

创建生产者线程


public class Producer extends Thread{
    private Phone phone;
    public Producer(Phone phone){
        this.phone=phone;
    }

    @Override
    public void run() {

        boolean flag=true;
        while (true){
            synchronized (phone){
                if(phone.isStore()){//有库存
                    try {
                        phone.wait();//wait：使当前线程等待，并把等待的线程记录在对象监视器（phone）中
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                if(flag){
                    phone.setBrand("华为");
                    phone.setPrice(3999);
                }else{
                    phone.setBrand("小米");
                    phone.setPrice(1999);
                }
                flag = !flag;
                phone.setStore(true);//设置为有库存
                phone.notify();//唤醒：唤醒对象监视器中第一个等待的线程
            }
        }
    }
}

创建 消费者线程


public class Consumer extends Thread {
    private Phone phone;

    public Consumer(Phone phone) {
        this.phone = phone;
    }
    @Override
    public void run() {
        while (true){
            synchronized (phone){
                if (!phone.isStore()){//没有库存
                    try {
                        phone.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(phone.getBrand()+"----"+phone.getPrice());
                phone.setStore(false);//设置成没有库存
                phone.notify();//唤醒：唤醒对象监视器中的第一个等待的线程
            }
        }
    }
}

创建Test测试


public class Test01 {
    public static void main(String[] args) {
        /**
         * 知识点：生产者消费者模型
         *
         * 注意：生产一个消费一个
         *步骤：
         * 		1.让生产者线程和消费者线程 共同操作同一个手机对象(资源)
         * 		2.让两个产品来回切换（目的是放大第一个步骤的问题）
         * 			加锁，防止脏数据的出现
         * 		3.生产一个消费一个
         */
        Phone phone=new Phone();
        Producer p=new Producer(phone);
        Consumer c=new Consumer(phone);

        p.start();
        c.start();
    }
}

结果展示
在这里插入图片描述

案例二、“多生产者”与“多消费者”情况下

提示：案例二与案例一的区别在 生产者（Producer） 与消费者（Consumer）的线程方法中，理解使用while 与 if 的不同情况下的不同影响。

实体类 phone


public class Phone {
     private  String brand;
     private double price;
     private boolean isStore;

     public Phone(){

     }
     public Phone(String brand,double price){
         this.brand=brand;
         this.price=price;
     }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public boolean isStore() {
        return isStore;
    }

    public void setStore(boolean store) {
        isStore = store;
    }
}

创建生产者线程类


public class Producer extends Thread{
   private Phone phone;
   private static boolean flag=true;

    public Producer(Phone phone) {
        this.phone = phone;
    }

    @Override
    public void run() {
        while (true){
            synchronized (phone){
                while (phone.isStore()){//生产者有库存
                    try {
                        phone.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (flag){
                    phone.setBrand("华为");
                    phone.setPrice(3999);
                }else {
                    phone.setBrand("小米");
                    phone.setPrice(1999);
                }
                flag=!flag;//使得 华为 与 小米 交替生产
                phone.setStore(true);//设置为有库存即 生产者 将进入等待wait
                phone.notifyAll();//唤醒对象监视器中所有等待的线程
            }
        }
    }
}

消费者线程类


//消费者线程
public class Consumer extends Thread{
    private Phone phone;

    public Consumer(Phone phone) {
        this.phone = phone;
    }

    @Override
    public void run() {
        while (true){
            synchronized (phone){
                while (!phone.isStore()){//没有库存
                    try {
                        phone.wait();//使当前线程处于等待并保留其进程
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(phone.getBrand()+"----"+phone.getPrice());
                phone.setStore(false);//设置成没有库存
                phone.notifyAll();//唤醒对象监视器中所有等待的线程
            }
        }
    }
}

测试类Test01


public class Test01 {
    public static void main(String[] args) {
        /**
         * 知识点：多生产者 与 多消费者的模型
         * 注意：多个生产者多个消费者的情况
         * 需求：生产一个消费一个
         * 步骤：1、让生产者和消费者线程共同操作同一个手机对象（资源）
         *      2、让两个产品来回切换，（目的是放大第一个步骤的问题）
         *      3、生产一个消费一个
         *
         *
         *总结：
         * 1、多个生产者多个消费者   if  变成  while ，初始唤醒线程之后再次判断是否符合库存没有就在一次等待
         * 2、对象监视器该如何选择？ 锁对象可以当做对象监视器使用，因为锁对象是多个线程共用的，二对象监视器可以在A线程中唤醒B线程
         * 3、 sleep（休眠）属于Thread类的方法，不会释放锁，wait（等待）属于Object类的方法，会释放锁
         *
         */
        Phone phone=new Phone();
        Producer p1 = new Producer(phone);
        Producer p2 = new Producer(phone);
        Consumer c1 = new Consumer(phone);
        Consumer c2 = new Consumer(phone);

        p1.start();
        p2.start();
        c1.start();
        c2.start();
    }
}

三、仓储模型

使用场景：通过一个中间角色来调控生产者与消费者两个线程之间的生产关系

附图理解

在这里插入图片描述

案例如下：

案例一、单个“生产者”与“消费者”情况下

创建蛋糕实体类 Cake


public class Cake {
    private String brand;
    private String dataTime;
    public Cake(){

    }
    public Cake(String brand,String dataTime){
        this.brand=brand;
        this.dataTime=dataTime;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getDataTime() {
        return dataTime;
    }

    public void setDataTime(String dataTime) {
        this.dataTime = dataTime;
    }

    @Override
    public String toString() {
        return "Cake{" +
                "brand='" + brand + '\'' +
                ", dataTime='" + dataTime + '\'' +
                '}';
    }
}

创建 仓库类 Store

import java.util.LinkedList;

public class Store {
    //蛋糕容器
    private LinkedList<Cake> list=new LinkedList<>();//由于涉及到先生产的蛋糕想卖掉的关系所以和队列有关，因此选择LinkedList来进行储存
    //最大容量
    private int maxCapacity=20;
    //当前容量
    private int currentCapacity;
    //入库
    public void push(Cake cake)  {
        synchronized (this){
            if (currentCapacity>=maxCapacity){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            list.add(cake);
            currentCapacity++;
            System.out.println("入库成功，当前的容量为："+currentCapacity);
            this.notify();
        }
    }
    //出库的方法
    public void pop(){
        synchronized (this){
            if (currentCapacity<=0){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Cake cake=list.removeFirst();
            currentCapacity--;
            System.out.println("出库成功，当前容量为："+currentCapacity+"---"+cake);
            this.notify();
        }

    }
}

创建生产者线程


import java.text.SimpleDateFormat;
import java.util.Date;

public class Producer extends Thread {
    private Store store;
    public Producer(Store store){
        this.store=store;
    }

    @Override
    public void run() {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        while (true){
            Cake cake=new Cake("面包",sdf.format(new Date()));
            store.push(cake);
        }
    }
}

创建消费者线程

public class Consumer extends Thread {
    private Store store;

    public Consumer(Store store) {
        this.store = store;
    }

    @Override
    public void run() {
        while (true){
            store.pop();
        }
    }
}

案例二、多个“生产者”与“消费者”情况

区别：还是与之前的模式一样 就是在 仓库Store中的时候对于生产者与消费者的不同操作 使用 while 或 if 来控制 最后达到唤醒 notifyAll（） 唤醒多个任务线程的目的

案例如下：
创建实体类Cake


public class Cake {
    private String brand;
    private String dataTime;
    public  Cake(){
    }

    public Cake(String brand, String dataTime) {
        this.brand = brand;
        this.dataTime = dataTime;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getDataTime() {
        return dataTime;
    }

    public void setDataTime(String dataTime) {
        this.dataTime = dataTime;
    }

    @Override
    public String toString() {
        return "Cake{" +
                "brand='" + brand + '\'' +
                ", dataTime='" + dataTime + '\'' +
                '}';
    }
}

创建仓库Store


import java.util.LinkedList;
public class Store {
    //蛋糕容器
    private LinkedList<Cake> list=new LinkedList<>();
    //最大容量
    private int maxCapacity;
    //当前容量
    private int currentCapacity;
    //入库的方法
    public void push(Cake cake){
        synchronized (this){
            while (currentCapacity>=maxCapacity){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        list.add(cake);//符合条件的话 就直接加入到仓库里去
        currentCapacity++;
        System.out.println("入库，当前容量为："+currentCapacity);
        notifyAll();//如果没有满仓库的话  就用这个唤醒所有线程 满了的话 这句话就没有啥用处
    }
    //出库的方法
    public void pop(){
        synchronized (this){
            while (currentCapacity<0){
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Cake cake=list.removeFirst(); //如果满了 就移除掉第一个蛋糕，先做出来的先卖掉 否则会过起先
            currentCapacity --;
            System.out.println("出库成功，当前容量为："+currentCapacity+"---"+cake);
            this.notifyAll();
        }
    }
}

创建生产者线程


import java.text.SimpleDateFormat;
import java.util.Date;

public class Producer extends Thread{
    private Store store;//由于需要操纵仓库 所以需要传递一个仓库


     //构造方法
    public Producer(Store store) {
        this.store = store;
    }

    @Override
    public void run() {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        while (true){
            Cake cake=new Cake("桃李面包",sdf.format(new Date()));
            store.push(cake);
        }
    }
}

创建消费者线程


public class Consumer extends Thread {
    private Store store;

    public Consumer(Store store) {
        this.store = store;
    }

    @Override
    public void run() {
        while (true){
            store.pop();
        }
    }
}

总结

以上就是今天要讲的内容，本文仅仅简单介绍了以后项目中经常要使用到的线程三大设计思想理念模式，我个人会死记于心。

sugar-free->小粽子
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java实现多线程（车站卖票）
南 墙
07-30 1万+
import java.util.ArrayList; import java.util.List; public class 多线程 { // public static int j=0; public static long a=0; public static void main(String[] args) throws InterruptedException { List&l...
JAVA多线程模拟火车站售票大厅
forthenight996的博客
05-18 5267
文章目录实验要求一、程序流程图（试验原理）二、变量说明三、功能分析及设计四、多线程卖票的实现五、实验结果及代码代码： 实验要求 用多线程设计一个模拟火车站售票大厅的工作情形。火车站有许多售票窗口，有些开放，有些不开放。用多个线程去订票，不能有两个或者以上的线程订到同一个票，当最后一张票卖掉时，再订就异常提示出票卖完了。每个窗口买票需要1-3秒的时间，每次卖票需要打印出买票的时间和买票的窗口名。 一、程序流程图（试验原理） 二、变量说明 count:当前剩余总票数 place[]:途径站点 num:本
Java并发-多线程售票案例
abc123mma的博客
11-28 1179
Java并发-多线程售票案例
【Java篇】Java多线程完成火车票售卖案例
破烂码农
04-18 4163
我们在学习Java多线程时，可能最典型的一个案例就是火车票售卖，那么如何在不重复售票的情况下卖出全部火车票，我们通过Java多线程来完成，并根据 synchronized 同步锁关键字来限制同时卖出一张票的情况！
Java多线程（含生产者消费者模式详解）
yangsf_的博客
03-26 6925
Java简单并发问题解决！含生产者消费者模式详解，管程法与信号灯法！
javase多线程实现生产者消费者问题
11-01
javase多线程中的经典案例，生产者消费者问题,详细见代码
Java SE程序 生产者+消费者
01-21
Java SE程序 生产者+消费者Java SE程序 生产者+消费者Java SE程序 生产者+消费者Java SE程序 生产者+消费者Java SE程序 生产者+消费者Java SE程序 生产者+消费者Java SE程序 生产者+消费者Java SE程序 生产者+消费者...
javase之多线程技术
10-16
标题：进阶课程之并发编程快速入门与多线程实战项目> 课程内容： 1.CPU调度算法原理（先来先服务、最短作业法、优先级调度算法） 2.站在字节码角度+cpu上下文切换角度分析线程安全问题 3.手写Callable与FutureTask...
javaSE多线程的案例源代码
04-01
源代码可能展示了生产者消费者模型或其他线程协作模式，如哲学家就餐问题的解决方案。 通过分析和学习这些源代码案例，开发者可以更深入地理解Java多线程的原理和实践，从而编写出更加健壮、高效的并发程序。对于...
JavaSE之多线程实战视频课程
06-09
多线程的概念在Java中实现多线程Thread类Runnable接口线程的生命周期和线程状态后台线程线程同步
JAVA多线程实现卖票的五种方式
最新发布
01-05 949
JAVA多线程实现卖票：AtomicInteger、volatile、synchronized、ReentrantLock、ThreadLocal。
两种常用的线程模型
u011008528的专栏
03-07 570
两种线程模型：       1、生产者-消费者模型 ，就是由一个线程生产任务，而另外一个线程执行任务，二个线程之间有一个共享数据区，这种数据结构可以用队列来表示，但是必须是并发同步的，也就是就共享数据队列同一时间只能允许一个线程进行访问。这种机制叫做同步访问，在JAVA里面用关键字synchorinized 来标识对象是同步并发访问的。        生产者/消费者模式是一种很经典的线程同步模
Java简单的多线程卖票
weixin_52210086的博客
04-09 4316
package xiancheng; /* 定义一个MaiPiao类实现Runnable接口，里面定义一个成员变量: private int tickets =100(票数); 在类中重写run()方法实现卖票，代码步骤如下 1：判断票数大于0，就卖票，并告知是哪个窗口卖的 2:卖了票之后，总票数要减1 3：票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行 定义一个测试类MaiPiaoDemo，里面有main方法，代码步骤如下 1:创建MaiPiao类的对象 2:创建三个Th.
生产者消费者模型+仓储模型及Java自带的线程池
GL280599ZL的博客
10-31 362
1.产品类 – Phone2.生产者线程 – Producer3.消费者线程 – Consumer。
剖析生产者和消费者模型
风华绝代
05-29 629
每天进步一点点，加油！！！
多线程--05--线程安全问题---售票模型--synchronized--Lock锁
时光里的博客
11-13 403
案例1： 创建三个窗口卖票，总票数为100张. 使用继承Thread类的方式 class Window extends Thread{ private static int ticket = 100; @Override public void run() { while(true){ if(ticket > 0){ System.out.println(getName() + "：卖票，票号为："
多线程卖票实例
Syals的博客
05-09 410
使用多线程的方式来实现多个窗口卖票，使用synchronized来保证线程安全和数据的一致性
思考：以卖票为例子思考Actor模型(3种卖票方案对比)
focus-unchanged-thing
10-30 1133
假如票有100张，多线程卖票，如何保证并发 安全 呢? 1)常见思路（单体） 比如：保证 多线程对于票的修改是线程安全 的。 因此：需要加锁。在 每个线程修改的地方 synchronized(ticket){ // 检测票是否足够 // 足够则通知发货 } 2)actor模型 TicketActor： 票actor，维护票数，只有它有修改的权利。 PlayerActor：有多个，想要卖票 ，先向TicketActor发起询问，TicketActor查询票是否足够，够了则通知下单。
java多线程——生产者与消费者模型
L04593的博客
08-30 270
生产者与消费者 生产者与消费者模型 1.一个生产者一个消费者 步骤： 1.让生产者线程和消费者线程 共同操作同一个手机对象(资源) 2.让两个产品来回切换（目的是放大第一个步骤的问题）加锁，防止脏数据的出现 3.生产一个消费一个 代码实现： package com.dream.producer_consumer01_type01; public class Test01 { public static void main(String[] args) { Phone phone = new
JavaSE专题-多线程总结.doc
06-03
多线程技术是一种能够在同一进程中同时执行多个线程的技术。多线程技术可以提高程序的运行效率，充分利用计算机的多核处理器，使得程序能够更加灵活地处理各种任务。在Java中，多线程技术是非常重要的，因为它可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

sugar-free->小粽子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值