统筹案例-烧水泡茶

已于 2022-06-12 14:59:12 修改
阅读量1.4k 收藏
点赞数
分类专栏： JUC编程篇 文章标签： java
于 2022-06-12 14:25:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjj_flower/article/details/125245141
版权

统筹方法，是一种安排工作进程的数学方法。它的实用范围极广泛，在企业管理和基本建设中，以及关系复

杂的科研项目的组织与管理中，都可以应用。

怎样应用呢？主要是把工序安排好。

比如，想泡壶茶喝。当时的情况是：开水没有；水壶要洗，茶壶、茶杯要洗；火已生了，茶叶也有了。怎么

办？

  • 办法甲：洗好水壶，灌上凉水，放在火上；在等待水开的时间里，洗茶壶、洗茶杯、拿茶叶；等水开了，泡茶喝。

  • 办法乙：先做好一些准备工作，洗水壶，洗茶壶茶杯，拿茶叶；一切就绪，灌水烧水；坐待水开了，泡茶喝。

  • 办法丙：洗净水壶，灌上凉水，放在火上，坐待水开；水开了之后，急急忙忙找茶叶，洗茶壶茶杯，泡茶喝。

哪一种办法省时间？我们能一眼看出，第一种办法好，后两种办法都窝了工。

这是小事，但这是引子，可以引出生产管理等方面有用的方法来。

水壶不洗，不能烧开水，因而洗水壶是烧开水的前提。没开水、没茶叶、不洗茶壶茶杯，就不能泡茶，因而

这些又是泡茶的前提。它们的相互关系，可以用下边的箭头图来表示：

从这个图上可以一眼看出，办法甲总共要16分钟（而办法乙、丙需要20分钟）。如果要缩短工时、提高工作

效率，应当主要抓烧开水这个环节，而不是抓拿茶叶等环节。同时，洗茶壶茶杯、拿茶叶总共不过4分钟，大

可利用“等水开”的时间来做。

是的，这好像是废话，卑之无甚高论。有如走路要用两条腿走，吃饭要一口一口吃，这些道理谁都懂得。但

稍有变化，临事而迷的情况，常常是存在的。在近代工业的错综复杂的工艺过程中，往往就不是像泡茶喝这

么简单了。任务多了，几百几千，甚至有好几万个任务。关系多了，错综复杂，千头万绪，往往出现“万事俱

备，只欠东风”的情况。由于一两个零件没完成，耽误了一台复杂机器的出厂时间。或往往因为抓的不是关

键，连夜三班，急急忙忙，完成这一环节之后，还得等待旁的环节才能装配。

洗茶壶，洗茶杯，拿茶叶，或先或后，关系不大，而且同是一个人的活儿，因而可以合并成为：

看来这是“小题大做”，但在工作环节太多的时候，这样做就非常必要了。

这里讲的主要是时间方面的事，但在具体生产实践中，还有其他方面的许多事。这种方法虽然不一定能直接

解决所有问题，但是，我们利用这种方法来考虑问题，也是不无裨益的。

使用统筹法解决上述问题：

解法一：join

代码如下：

         Thread t1 = new Thread(() -> {
             log.debug("洗水壶");
             Sleeper.sleep(1);
             log.debug("烧开水");
             Sleeper.sleep(15);
         }, "老王");
 ​
         Thread t2 = new Thread(() -> {
             log.debug("洗茶壶");
             Sleeper.sleep(1);
             log.debug("洗茶杯");
             Sleeper.sleep(2);
             log.debug("拿茶叶");
             Sleeper.sleep(1);
             try {
                 t1.join();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             log.debug("泡茶");
         }, "小王");
         t1.start();
         t2.start();
 ​
 //说明： Sleeper.sleep(1);是自己封装的sleep工具类，提高代码可读性，具体实现时：
 ​
 public class Sleeper {
    
     public static void sleep(int i) {
         try {
             TimeUnit.SECONDS.sleep(i);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 ​
     public static void sleep(double i) {
         try {
             TimeUnit.MILLISECONDS.sleep((int) (i * 1000));
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }
 ​

使用join()实现的结果如下：

 11:47:21.548 c.TestPaoCha [老王] - 洗水壶
 11:47:21.548 c.TestPaoCha [小王] - 洗茶壶
 11:47:22.564 c.TestPaoCha [老王] - 烧开水
 11:47:22.564 c.TestPaoCha [小王] - 洗茶杯
 11:47:24.579 c.TestPaoCha [小王] - 拿茶叶
 11:47:37.573 c.TestPaoCha [小王] - 泡茶
 ​
 Process finished with exit code 0
 ​

解法一的缺陷：

  • 上面模拟的是小王等老王的水烧开了，小王泡茶，如果反过来要实现老王等小王的茶叶拿来了，老王泡茶

    呢？代码最好能适应两种情况；

  • 上面的两个线程其实是各执行各的，如果要模拟老王把水壶交给小王泡茶，或模拟小王把茶叶交给老王泡茶

    呢？

解法二：wait()/notify()

实现代码如下：

 @Slf4j(topic = "c.S2")
 class S2 {
     static String kettle = "冷水";
     static String tea = null;
     static final Object lock = new Object();
     static boolean maked = false;
     public static void makeTea() {
         new Thread(() -> {
             log.debug("洗水壶");
             Sleeper.sleep(1);
             log.debug("烧开水");
             Sleeper.sleep(5);
             synchronized (lock) {
                 kettle = "开水";
                 lock.notifyAll();
                 while (tea == null) {
                     try {
                         lock.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
                 if (!maked) {
                     log.debug("拿({})泡({})", kettle, tea);
                     maked = true;
                 }
             }
         }, "老王").start();
         new Thread(() -> {
             log.debug("洗茶壶");
             Sleeper.sleep(1);
             log.debug("洗茶杯");
             Sleeper.sleep(2);
             log.debug("拿茶叶");
             Sleeper.sleep(1);
             synchronized (lock) {
                 tea = "花茶";
                 lock.notifyAll();
                 while (kettle.equals("冷水")) {
                     try {
                         lock.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
 ​
                     }
                 }
                 if (!maked) {
                     log.debug("拿({})泡({})", kettle, tea);
                     maked = true;
                 }
             }
         }, "小王").start();
     }
 }
 ​
 ​
 ​
 //实现结果
 ​
 12:41:27.419 c.S2 [小王] - 洗茶壶
 12:41:27.419 c.S2 [老王] - 洗水壶
 12:41:28.423 c.S2 [小王] - 洗茶杯
 12:41:28.423 c.S2 [老王] - 烧开水
 12:41:30.434 c.S2 [小王] - 拿茶叶
 12:41:33.428 c.S2 [老王] - 拿(开水)泡(花茶)
 ​
 Process finished with exit code 0
 ​
 ​

解法2 解决了解法1 的问题，不过老王和小王需要相互等待，不如他们只负责各自的任务，泡茶交给第三人来做

解法三：使用第三者协助

代码如下：

 @Slf4j(topic = "c.S3")
 class S3 {
     static String kettle = "冷水";
     static String tea = null;
     static final Object lock = new Object();
     public static void makeTea() {
         new Thread(() -> {
             log.debug("洗水壶");
             Sleeper.sleep(1);
             log.debug("烧开水");
             Sleeper.sleep(5);
             synchronized (lock) {
                 kettle = "开水";
                 lock.notifyAll();
             }
         }, "老王").start();
         new Thread(() -> {
             log.debug("洗茶壶");
             Sleeper.sleep(1);
             log.debug("洗茶杯");
             Sleeper.sleep(2);
             log.debug("拿茶叶");
             Sleeper.sleep(1);
             synchronized (lock) {
                 tea = "花茶";
                 lock.notifyAll();
             }
         }, "小王").start();
         new Thread(() -> {
             synchronized (lock) {
                 while (kettle.equals("冷水") || tea == null) {
                     try {
                         lock.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
                 log.debug("拿({})泡({})", kettle, tea);
             }
         }, "王夫人").start();
     }
 }
 ​
 ​
 ​
 ​
 //*********************************实现结果***********************************
 ​
 ​
 12:40:09.643 c.S3 [小王] - 洗茶壶
 12:40:09.643 c.S3 [老王] - 洗水壶
 12:40:10.656 c.S3 [老王] - 烧开水
 12:40:10.656 c.S3 [小王] - 洗茶杯
 12:40:12.666 c.S3 [小王] - 拿茶叶
 12:40:15.666 c.S3 [王夫人] - 拿(开水)泡(花茶)
 ​
 Process finished with exit code 0
 ​
逐步绽放的海棠花
关注
专栏目录
FutureTask详解及典型用例----高并发实现烧水泡茶
weixin_42617262的博客
05-18 770
FutureTask详解及典型用例----高并发实现烧水泡茶 Future接口：作用为获取Callable接口的返回值 FutureTask类为Future接口子类，该类独有的特点为在高并发情况下不论有多少个线程，均只执行一次任务。 get()方法的作用为阻塞当前线程直到有返回值为止。 使用Future接口中get()方法的两种情况： (1)提交线程的同时调用get()方法 class Calla...
java实现“烧水泡茶”
m0_37732829的博客
12-30 420
烧水泡茶，烧水泡茶最优分工方案图如下 import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; import java.util.concurrent.TimeUnit; public class FutureTaskDemo { static class T1Task implements Cal
多线程学习九：煮茶算法
LHBGXX的博客
03-07 972
阅读华罗庚《统筹方法》，给出烧水泡茶的多线程解决方案，提示 参考图二，用两个线程（两个人协作）模拟烧水泡茶过程 文中办法乙、丙都相当于任务串行 而图一相当于启动了 4 个线程，有点浪费 用 sleep(n) 模拟洗茶壶、洗水壶等耗费的时间 附：华罗庚《统筹方法》 统筹方法，是一种安排工作进程的数学方法。它的实用范围极广泛，在企业管理和基本建设中，以及关系复 杂的科研项目的组织与管理中，都可以应用。 怎样应用呢？主要是把工序安排好。 北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090 洗水
JUC并发编程 Java线程 -- 应用之统筹（烧水泡茶）
天行健 君子以自强不息，地势坤 君子以厚德载物。
08-27 683
1. 应用之统筹（烧水泡茶） 阅读华罗庚《统筹方法》，给出烧水泡茶的多线程解决方案，提示: 参考图二，用两个线程（两个人协作）模拟烧水泡茶过程 文中办法乙、丙都相当于任务串行 而图一相当于启动了 4 个线程，有点浪费 用 sleep(n) 模拟洗茶壶、洗水壶等耗费的时间 附：华罗庚《统筹方法》 统筹方法，是一种安排工作进程的数学方法。它的实用范围极广泛，在企业管理和基本建设中，以及关系复杂的科研项目的组织与管理中，都可以应用。怎样应用呢？主要是把工序安排好。 比如，想泡壶茶喝。当时的情况是：
如何用多线程实现最优的“烧水泡茶”程序？
whutrenzhe的博客
09-30 217
如何用多线程实现最优的“烧水泡茶”程序？
【Java并发工具类-分工】Future如何用多线程实现最优的“烧水泡茶”程序？
邓新的博客
04-15 325
线程协作1. 如何获取任务的执行结果？1.1 三个submit（）方法1.2 submit()和execute()方法的区别？1.3 FutureTask工具类2. 实现最优的"烧水泡茶"程序 上一篇中如何正确创建线程池，介绍了ThreadPoolExecutor的execute(Runnable task)提交任务的方法，下面来讲解获取执行任务的返回结果。 1. 如何获取任务的执行结果？ jav...
32.java用多线程来模拟烧水泡茶，最优线路------一二熊猫冲冲冲
zjlzjlpy的博客
11-08 629
我们最近学习了java的多线程，现在我们来模拟一个烧水泡茶的最优过程。 上面的是过程图 下面直接上代码： package come; class xishuihu extends Thread { public void run() { System.out.println("开始洗水壶！！！"); System.out.println("水壶洗干净了！！！"); } } class nacaye extends Thread { public void run() { Syst
F_NCP_JZ_CY_0050 茶-袋泡茶滤纸和吊线的荧光增白剂测定-紫外灯法
01-01
俗话说国以民为本，民以食为天，食品的生产、安全、质量均需要相应的食品资料知识累积与制定，相信这一份...该文档为F_NCP_JZ_CY_0050 茶-袋泡茶滤纸和吊线的荧光增白剂测定-紫外灯法，是一份很不错的参考资料，具有...
烧水泡茶最优工序模拟（Java多线程）
zl871318846的博客
11-04 199
volatile修饰符： 每次使用volatile所修饰的变量时都要到主存中进行读取，避免了副本数据不一致，从而确保了多线程环境下各线程间共享数据的安全性。 烧水泡茶最优工序模拟： package test; class HeatUpWater extends Thread{ public void run() { System.out.println("Begin to boil water"); try { Thread.sleep(1500); } catch (Interrupt
行业文档-设计装置-一种倾斜式泡茶杯.zip
08-30
在本压缩包“行业文档-设计装置-一种倾斜式泡茶杯.zip”中，主要包含了一份详细的技术文档——“一种倾斜式泡茶杯.pdf”。这份文档着重介绍了创新的设计理念和实用技术，旨在优化人们的泡茶体验。以下是该文档中涉及...
煮茶大业--古树熟散
老友记茶舍
09-02 409
原文地址：煮茶大业--古树熟散作者： 大唐今    早就答应伍姐把配方写给她，拖了好几天，赶紧写出来吧，不然明年了。     茶品：伯韵2008年古树熟散   煮茶器皿：铁壶（最好自带滤网）   水：纯净水，0.4L左右（壶总容量0.6L）   置茶量：6g   烧水器：户外气炉         第一步：烧水 （将量好的水倒入壶中，开火煮）   第二步：温润泡 （将茶直接置
【C语言编程练习】20040. 计算将水从初始温度加热到最终温度所需的能量
Not Found 404
02-28 6178
题目 计算将水从初始温度加热到最终温度所需的能量 编写程序，计算将水从初始温度加热到最终温度所需的能量。程序应该提示用户输入水的重量（以千克为单位），以及水的初始温度和最终温度。计算能量的公式是： Q = M ×（最终温度 – 初始温度）× 4184 这里的M是以千克为单位的水的重量，温度以摄氏度为单位，而能量Q以焦耳为单位。 【输入用例1】1 20 30 【输出用例1】41840.00焦耳 【输入用例2】10 0 50 【输出用例2】2092000.00焦耳 【输入用例3】1 50 50 【输出
PID算法C语言程序STM32单片机控制水温实验（一、位置型PID）
热门推荐
wanglong3713的博客。
03-31 1万+
一、概述 实验所用器材均为容易买到的设备，主要有STM32F103C8T6最小系统板、DS18B20温度传感器、继电器模块、TM1638显示模块、电加热棒（12V/80W）、直流电源适配器（12V/10A），再找一个小一些的玻璃杯（水250ml），所有设备如下图。 二、系统功能 由于采用普通继电器控制加热棒，继电器不允许频繁启停，因此将控制周期设为1min，即每1min计算一次当前1min内电加热棒需要开启的时间（占周期的百分比），通过控制每一个控制周期内电加热棒的开启时间，使水温在设定温度附近恒定；因温
PID算法C语言程序STM32单片机控制水温实验（二、积分项改进）
wanglong3713的博客。
10-24 3914
该水温控制系统，传统PID与改进PID效果差不多，可能是因为该系统过于简单；另外P、I、D参数选取未经过大量实验，可能不是最优的，本例中的积分I参数非常小，所以积分项的改进效果不明显，但目的在于总结积分项的改进方法与C语言实现。有兴趣的可以试验整定参数，达到更好的效果。如有错漏之处，欢迎指正。
以烧水控温过程来介绍PID控制算法
Zzt的博客
06-16 6052
PID是一种控制算法，它的中文名称是比例积分微分控制。 这种控制的基本思路是根据偏差的大小运用比例、积分、微分计算出一个控制量，将这个控制量输入被控制的系统，系统接收到该输入量后会输出一个相应的输出量，PID控制器再检测该输出量，并再计算偏差，然后再循环以上过程，以下就是控制框图。这里P,I,D并不是都要加上去的，有时只用P或者只用PI。 ...
统筹学问题
最新发布
weixin_56141930的博客
04-03 1061
从本题看，各种状态的后悔值如下表所示： 根据上表所示，甲的最大后悔值为350，乙的最大后悔值为300，丙的最大后悔值为500，丁的 最大后悔值为400，最小值为乙的300。在不同的市场需求条件下，新产品的收益值如表所示。：下图为某地区的通信线路图，图中节点为8个城市，节点间标识的数字为城市间拟铺设通信线路的长度，为了保持8个城市通信连接，则至少铺设（ ) km的线路。采取消元法，我们求得X=6，Y=40，可以使得该公司的最大利润=6×3+40×4=178(万元)，这个时候生产甲乳制品生产的数量是6吨。
SpringBoot多线程 并行查询接口，并将结果合并返回
weixin_45399695的博客
05-31 6542
多线程并行运行接口并将结果合并返回(调整代码运行速率)
23. Future：如何用多线程实现最优的“烧水泡茶”程序？- 并发工具类
tobebetter9527的博客
10-24 832
文章目录1. 如何获取任务执行结果 1. 如何获取任务执行结果 ThreadPoolExecutor提供的3个submit()方法和1个FutureTask工具类来支持获得任务执行结果的需求。方法签名如下： // 提交Runnable任务 Future<?> submit(Runnable task); // 提交Callable任务 <T> Future<T>...
Java并发编程：练习：烧水泡茶
m0_58535137的博客
08-09 237
练习：烧水泡茶
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值