春节回了趟老家,又体验了一次流水席,由于桌席多,导致上菜慢,于是在等待间,总结了一下出菜流程的几个特点:

1.有多个灶台,多个灶台都在同时做菜出来。

2.做出来的菜,会有专人用一个托盘端出来,每次端出来的菜(是同一个菜品)的数量不等。

3.由于端出来的菜可能不能满足所有的桌数,所以,端菜人可能会随机选择几桌(一般是就近原则,或者是主桌先端过去)上菜,其余的桌数继续等待后面的端菜人出来。

以上3个条件,完全就是一个生产者消费者的场景,于是,把生产者消费者先来实现一下,然后再分析如何才能更快的上菜 :)

首先,我们把托盘给虚拟成一个资源池,表示这个托盘里是放菜的,当托盘里的菜大于1时,即有菜品被生产出来,端菜人就要端出去,当托盘里没有菜时,外面所有的桌席都要等待:

(需要特别注意的是,这个资源池只能有一个实例化对象,就像托盘的数量是固定的一样。)

public class ResourcePool {

	private int number = 0;

	public synchronized void producer(){
try {
while(number==3){
this.wait();
}
number++;
System.out.println("producer: "+number);
this.notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
} public synchronized void consumer(){
try {
while(number==0){
this.wait();
}
number--;
System.out.println("consumer: "+number);
this.notifyAll();
} catch (InterruptedException e) {
e.printStackTrace();
}
} }

其实,我们要有灶台,这个灶台是专门做菜的,做出来的菜,当然是全部放在了资源池(即托盘中),灶台是会有多个的,所以要继承thread类:

public class ResourceProduce extends Thread{

	private ResourcePool rp;

	public ResourceProduce(ResourcePool rp) {
this.rp = rp;
} public void run() {
rp.producer();
} }

托盘中有了菜,就得端出去了,给送到外面的桌席上去,由于桌席是多桌,所以,也要继承thread类:

public class ResourceConsumer extends Thread{

	private ResourcePool rp;

	public ResourceConsumer(ResourcePool rp) {
this.rp = rp;
} public void run() {
rp.consumer();
} }

这些基础的设施都准备好后,我们的端菜人就出来了:

public class ResourceUtil {

	public void resource(){
ResourcePool rp = new ResourcePool();
for (int i = 0; i < 3; i++) {
new ResourceProduce(rp).start();
}
for (int i = 0; i < 5; i++) {
new ResourceConsumer(rp).start();
}
} public static void main(String[] args) {
ResourceUtil ru = new ResourceUtil();
ru.resource();
} }

我们来看一下最后的输出结果:

aaarticlea/png;base64,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" alt="" />

当只有三个灶台,而桌席有5桌时,程序就等待下去了,于是,当我们把灶台数改成5后,运行结果:

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXcAAACRCAIAAAC3yG+CAAAP4UlEQVR4nO2dr5byPBDGua6K3gVXsOdUoPEY1qcCi0Mh1nHWvuegUKswqBV7PsFF5BP9N0kmbdI2kLbP77yC7VuagTYPmUkys5IAABCS1bsNAADMnBeqzOPrsFofxJ969O9fst6t1jvzvy45czAELQ1d8t1qfb4EN+FlXLJVVn+ch0gS8bCctlqtyKkA9OftKmP/L6jM2DxEognHJeOkxDwPgAFErDIxMCeV4bXjkq2M8Qx3DIDeDFaZx9dhtT5neeH17LJbfbBUjbqjFgez/EDPJBchKmNzo5rju9X2H98PinPyO/0z+XpWlqiXtTREzmxXmUu2yoRIVivFwXjUR1T3pDrYdGHmTOLTEF3gG6pdm87W7dLBiA9UBozKOCpT9mpNUDiV0c8kF9HHMrz01PJhh168EEGbSWxDLWeaTWWNZlTyQEMfTX9VAiJlQyKp39y8tqqM0RDr7/CttykH60fBYQLjMY7KVF30di5et4xltDOZi7BX9vKq/v4l5VjpKbbFQOYptkSh2lp/im0zUHJQGU47KGXfLg+Ts7XezYiUNpbRzeCEw9J6q3JoYoSgLxiZUVWmft2pMi4K0l9lak35+5eUb3mdyrS7G4WHk11kIJWxtu6oMlqzAIzAmCrT9M/mYBn40FRG6cnSTWXcPSYpCx05i69DfT6ZSOpovVEWYrwFS+dv7aR1J7Z6TMWLYljSojIPkbAeE9u6p8eEuAwYj7HiMnqg9J5VR4QSGdHPVA9Wx29n5qB23Bb9VQ0gMean2LZesDnOGG+BHyFQt0V1mOzBWyYinAiRtamMdlkm+kvFAtFf8C7GjcuAiMFMNngTUJkFgVV54C1AZZaF4nnZI8LmjBgAvcFuSQBAWKAyAICwQGUAAGGByryTeiIbAZAZ0H43HXNuzJI4VYbsAYx6TpXa2VspZj+jg7vpPLs3U6JVGbKaLd4nU9sN0M/QJajMsu+m+0qlmRK7yih3KLqMCnQUTC7aZaf6xDmpzM8+PZ5On2m6SdNNuv+RUsrrMd1/nz42abpJ08/Tb9e36gCbx6M6TlJkqBvByK5UjqXfTb9V13Mc4sSuMmRgGWFGBXKwvhDbOm+SYY2dn326+Tj9V70+XqWU12OabvZXKaX8PX2mH982ndE3atubI9k5yG4voinlJq9mG2rBU2yVhEEKC7+bnjvIoDKvgvz21DcoxowKTMSBbd1iEmsvT6UslOuxHNRIKX+/P8wT/GE306s5vYrhzD1b77Jbnb6n/JNn4XfTYzf8XIlWZeofDfIzF11GBctPb2wq4zmWYVVG2zJauEh3sT1n+UHctKGNysLvJlQmcpVRshtEmFHB9u4gHlObylz3m0ZxBtCS5FAbqlzyXZKfk/z++Dok+Tlp2bm+8Lvp7THNT3hiVxnF144uo4Ll3Vzr3EF9jNHS6ywqUwSD001LUMYLWzZSJUFHk0Jol92qLDwtiTiWfjc9or+KZs6HOFUGuEA9JhAxHjPZcc/19wUqM12gMpPBZVVeMY6Zn8RIqMyUgcpMCcecG7MEKgMACAtUBgAQFqgMACAsUatMXUvAvq60D7pTTIqojMbv6TMdYzHuiMzMJM/kCeXU85KiIfEQr8roVZNGgtui5qgyTcnKbkbv0s1qjL6zECObpC4P6dd7h5nkkTxh9vve4yZelbln7jXenBn0tPmozMiQDvWqDtPVTjg72AkY20E3zV3KUv5ImZTKkG171dCj3BxcVXTrUCXjYSurR+6MgrZa9oPGd3OoOfezL5fkjjZw0HInGOtinbZ0+5hENzdbsKvMUJPcVcZZ6qAybyVGlaFFILUl7cbi979/yfqQ5WetODeP5VnjCnIb2Q+k51jGYZO08ybGui8VnV/Qj+GRK8Bx37aDwujWq6cPNclDZVxlZmHrU2IjRpUp0MYyT7Elf9YZT7yKZ9ueVEZlmL08o6uMM0VXqr2mvj/MrsLn2x97vYkxyVDdVSIe7EFyhc4vY6YpWybFLFTGtedHpjLuCRmUrbq9AyIeYxm/Bvpvvhk8lnGTXAR/38tkVIbOBBFHxldlXD0mq8pY805qjDmWUSzXZlY8cgV4mOToNfEnDzUpjMeEuMz7mI7KqPGaXuML82G7ndUscHU6FU5laPi5Jfr7+/1RJ2QYLwZsm8l2yhXQxySXOSZ+bn2oSYj+zo14VSYIMxw6R5gr4GUmYSZ7GixMZealMxHmCnilSViVNxUWpzIS05rzwPMumnnLwctYosoAAF4JVAYAEBaoDAAgLFAZ4EOAMGrPMJln5odXonyiiO18GVCZITDVCKOE2jlMJMZWmSHX85hjGrnltre7JBJfGlCZIaj1zOLVGa0S4wBDx1WZoVcbsgwmjMp4FEVZEItRGS6fQ32cJH8gleellFWpVsuuAi0jA1NRTBk5m8Me5kx7bVZRn8wVRGtrnQ7hm4vy1+wynhSHZOx0Nkn7+kp+9unxdPosFwQXFRqux3T/ffoolgh/npTqdk5SYXzzxgaypuybOeIzvyXb29lPZLVzSbs4l6UyRj4HoinlZoI/reTzU2xb68yTB5QpcKicoD9S1tqsvMrQnUx1R+dqs5qtk4PkQsw1rSaZObTsdjqZJNku+bNPNx+n/6rXx6ssS2jur1IWufXUKpoOMtNnB1TXN295u3exWqjMvLDXmaf/DuLvnq132a0c+1xk+ScP+fGzFjJVi7OSx8pS1N0+lnF5pvnW+fiReU3eJNpOh8q4m8R/po5y4Mzuym5nxLIej5MJLn7lI1ItgexFO01QGb2MfOEi3cX2nOUHcdOGNirVo/MQCR0htDxOxXOcXWQgleFb55/+F6mM9Qt5kco0J650J9AYXTD+L1RmOMtWmaakPOGS75L8nOT3x9chyc+JLkP0VCX62+LHKJZUz6fVPaHRg5Znnc0exbbuqjK8Sc1BahJrp7tJku14HSpz3W+0cppenogRP1KaJ5+dXsMnsY23x7QQ4Vm2ylTHzdSfu+xWJeJrSfKgRRk074hxmLTIIhmiMxHhRIjM4RdVvyrTurPKdJmUXZo3sXY6m6R/fQUWlakTRKhBGa7zGmknLN+88j969Nfhm+dzcXhEf53yY8yExagMiBCnKaKWcuDxuSEeM9lxL34YFagMeCcOOmNVmThXu7msyoswZUdQoDLgzXTtMLCoTMT5OxTTIrbzZUBlAABhgcoAAMIClQEAhCVSlUH+RABmQ6QqI6WMcZ4SAOBPzCqD8DwAcwAqAwAIS+wqA5cJgKkTtcpIdbczAGCKRK0yGMsAMANiVxnEZQCYOlAZAEBYoDIAgLDErDIIywAwByJVGewwAGA2RKoyAIDZAJUBAIQFKgMACEvUKnPP1nrB2THQp64u+W7VUnSpF7+nz9RMx/9WZmbSQyQ+cwNlfQJE+t5BvCpD6syOCVex2FFl/v4lzno3epfm6nL4MbJJasnIfr13mEke2cWdiiWAUMSrMvesLGs9JoOeNh+VGRm2UnVYutoJZwe7TMp20LmwJBZFvI9JqQwpa10NPf6KCrNPsd2tulXJeNiKum5rZSxTVMjOcuqsNb4brQ9n4WdfVikbbeCg1VY16sZ19nZfk2gJegt2lRlqkrvKOEsdVOatxKgylWQwJR+N4pB//5L1IcvP4k85gcfyrGlvLKtN5nfda/May5gVnc12tTL11v5S96Wi84tMrWbo6jc4mFRd0aFLWupFjmCSh8q4ygxWkb+VGFWmQBvLPMWW/Hk7l7pQDEYcHSvbk8qoDFPrdnSVcaboSrXX1PeH2VX4fPtjrzcxJhmqu0rEgz1IrtD5ZXhoHgjELFTGtedHpjLOYxm1cnvvgIjHWMavgf61WAePZdwkF8Hf9zIZlaEzQcSR8VUZV4/JqjLJ19OprTHHMorl2syKIkCjmeToNfEnDzUpjMeEuMz7mI7KqPGaXuML82G7nZUA0Pp8aVEZGn5uif7+fn+Ucc0xY8C2mWw9GjyaSS5zTPzc+lCTEP2dG/GqTBBmOHTu764E42UmYSZ7GixMZealM8WgIaru80qTsCpvKixOZSSmNeeB511ELpE3skSVAQC8EqgMACAsUBkAQFigMiBGesbOPNNBvBLlE0VsZwigMkMok5YMSsjwKoitsZs6ZEbIY+Jp5Jbb3m7+xzA7JwZUZgjNMowIV60QBuw0ej1DZ52HrI0JozL84QWt4VmMynD5HOrjJPlDvUOq5Cm29l0FWkaG6kkiy2KVQbI5lmDOJCNrcs1LtspEfbKW+EE9aF7T1ncsrdftsHaSnQ66nQ+RJEIU+wtEphmgm97yibTO97NPj6fTZ7lKeP8jpZTXY7r/Pn0U64Y/T7/6x+qUCuMTGbvKSivoeLXFeNvb2U9ktXOmWzuXpTJGPgeiKeVmgjJhTf2+p9jadzA0zw8ZAFMHXDlBf3ro+Kd5bVUZs39zo26mdX6cZW19ZV6di5LwKrNaZZfK2Cr4YP1COMViuuTPPt18nP6rXh+vUsrrMU03+6uURcK9j2+qMw4y02dbVNftsLzdPmbh/SiozHRhdyeRtFj1cOaerXfZrRz7XGT5Jw8X69B/1IhLpT5B2jNWPaz2sYzL48u1zqqMV+vckjaLymQXqm5V8/wYgetOzOFKWSjXYzmokdyWy25nxLJIj5MJOphpux2Wt7cFspfiNEFlyGZIKWXlIt3F9pzlB3HThjYq1VPyEAntPS1PzqVxJIKoDNs6N+bxat003kNlLF/Ie1WG+0S2z8w4xVAZL5atMoUbpQ1VLvkuyc9Jfn98HZL8nOgyRE9Vor8tfoxiSfUoWn0WGihoeazZmC7bOnemj7/GGM/ZyauM5QuxqwzjMbWpzHW/aRTHYnmLJ6KerDdPviV6DZ9sN94e0/yEZ9kqUx03U3/usluViK8lyQN9gIirziSrVNwGLnjLRFoTITKHH0/9qnyqTG7SnWmdVRneeNNOi8rwJrl3VIvK1Fkj1KAM13mNXBSW26H8jx79dbgdfIIOj+ivU9KM6bEYlQFTwWmKiHpMGvG5IR4z2XGviOgLVAZEh4POWFUmztVuLqvyIszjMRZQGRAjXTsMLCoTcVIPxbSI7QwBVAYAEBaoDAAgLFAZAEBYIlUZ5E8EYDZEqjJSyhinJAEA/sSsMkuLxAMwT6AyAICwxK4ycJkAmDpRq4xUdzsDAKZI1CqDsQwAMyB2lUFcBoCpA5UBAIQFKgMACEvMKoOwDABzIFKVwQ4DAGZDpCoDAJgNUBkAQFigMgCAsIygMoihAABaGGssg/kgAADPaB4T1rYAAFigMgCAsIypMnCZAAAmY84xIUsDAMAEYxkAQFgQlwEAhAUqAwAIC1QGABAWrMoDAIQFOwwAAGHBbkkAQFigMgCAsEBlAABhgcoAAMIClQEAhAUqAwAIC1QGABAWqAwAICxQGQBAWKAyAICwQGUAAGH5Hx2Q14VWx406AAAAAElFTkSuQmCC" alt="" />

producer: 1
producer: 2
producer: 3
consumer: 2
producer: 3
consumer: 2
producer: 3
consumer: 2
consumer: 1
consumer: 0

通过上面的程序运行,如果想上菜速度快,还是得加灶台,多加厨师,当然,这只是就这个场景简单的分析了一下,可能还会有更复杂的因素没考虑到,举这个例子的主要意思,是想让多多的理解一下生产者消费者模式,该模式我们平常可能用原生的比较少,但其实使用的场景一直都在用,比如线程池,连接池,等等。所以,知其然也知其所以然也很有必要,我们接着就代码来说明一下这个实现代码中的重点:

1.资源池有且只有一个。

2.synchronized,是锁对象,简单说一下:一个对象有且只有一把锁,当有多个synchronized方法或代码块都向该对象申请锁时,在同一时间,只会有一个线程得到该锁并运行,其它的就被阻塞了。

3.wait,是指该线程等待,wait有一个很重要的点,就是释放锁,上面也说了synchronized在同一时间只会有一个线程得到该锁并运行,所以,一旦wait后,就会释放锁,但当前线程等待下去,其它的线程再竞争这把锁。

4.notifyAll是指唤醒当前对象的所有等待的线程。

5.所有唤醒的线程会同时去竞争这把锁,但是JVM会随机选择一个线程并分配这把锁给该线程。

6.上面的synchronized wait notifyAll都是对一个对象进行操作,但这三个都是用在了资源池的类里面,所以,这也是资源池有且只能有一个的原因。

后绪:至于生产者消费者能给我们测试带来什么样的帮助,我暂时还没想到,但了解一下,出去面试时,有很大的可能性会被问到,有兴趣的,就当作一种知识储备吧。

JAVA生产者消费者的实现的更多相关文章

  1. 基于Java 生产者消费者模式(详细分析)

    Java 生产者消费者模式详细分析 本文目录:1.等待.唤醒机制的原理2.Lock和Condition3.单生产者单消费者模式4.使用Lock和Condition实现单生产单消费模式5.多生产多消费模 ...

  2. Java生产者消费者的三种实现

    Java生产者消费者是最基础的线程同步问题,java岗面试中还是很容易遇到的,之前没写过多线程的代码,面试中被问到很尬啊,面完回来恶补下.在网上查到大概有5种生产者消费者的写法,分别如下. 用sync ...

  3. java 生产者消费者问题 并发问题的解决

    引言 生产者和消费者问题是线程模型中的经典问题:生产者和消费者在同一时间段内共用同一个存储空间,如下图所示,生产者向空间里存放数据,而消费者取用数据,如果不加以协调可能会出现以下情况: 生产者消费者图 ...

  4. Java生产者消费者模型

    在Java中线程同步的经典案例,不同线程对同一个对象同时进行多线程操作,为了保持线程安全,数据结果要是我们期望的结果. 生产者-消费者模型可以很好的解释这个现象:对于公共数据data,初始值为0,多个 ...

  5. java 生产者消费者问题 并发问题的解决(转)

    引言 生产者和消费者问题是线程模型中的经典问题:生产者和消费者在同一时间段内共用同一个存储空间,如下图所示,生产者向空间里存放数据,而消费者取用数据,如果不加以协调可能会出现以下情况: 生产者消费者图 ...

  6. Java 生产者消费者模式详细分析

    */ .hljs { display: block; overflow-x: auto; padding: 0.5em; color: #333; background: #f8f8f8; } .hl ...

  7. Java生产者消费者问题

    1. package interview.thread; import java.util.LinkedList; import java.util.Queue; import org.apache. ...

  8. Java生产者消费者模式

    为什么要使用生产者和消费者模式 在线程世界里,生产者就是生产数据的线程,消费者就是消费数据的线程.在多线程开发当中,如果生产者处理速度很快,而消费者处理速度很慢,那么生产者就必须等待消费者处理完,才能 ...

  9. java生产者消费者并发协作

    随着职务转变,代码荒废很久了,很多时间都是在沟通需求,作为一名技术员,不写代码就感觉是在自废武功,慢慢颓废了很多,今天重新回顾了下JAVA线程知识,基础知识就不梳理了,网上也很多,主要关键几个状态位( ...

随机推荐

  1. C#压缩文件 不压缩路径

    我想把 E:\\AA\BB\11.txt 压缩后存入 E:\\AA1\BB1\11.rar 但是当我解压( E:\\AA1\BB1\11.rar)的时候,发现:11.txt 不是在 E:\\AA1\B ...

  2. STL学习之路

    本文面向的读者:学习过C++程序设计语言(也就是说学习过Template),但是还没有接触过STL的STL的初学者.这实际上是我学习STL的一篇笔记,老鸟就不用看了. 什么是泛型程序设计 我们可以简单 ...

  3. FME规划数据GIS更新入库

    规划数据经过转换处理入库GIS,城市规划的特殊性,使得GIS里面数据经过分析处理后直接导出为CAD数据的话,肯定难以满足原来规划的要求,这个是硬伤.又要用GIS来进行空间分析处理统计,数据管理就必须了 ...

  4. 比较有价值的参考文档-----------------URL

    http://www.wendangku.net/doc/f7b4349108a1284ac85043bf.html             曙光服务器的IPMI http://noob.blog.1 ...

  5. 5.11-5.15javascript制作动态表格

    制作动态表格的主要是运用js中表格类的insertRow.insertCell简易添加行和列的代码,不过要注意每行添加的表格是有位置行编号的,每行的编号为rows.length-1,增加的表格内的标签 ...

  6. jsp中利用response.senddirect(str)重定向,传递参数新思路

    用Servlet进行请求重定向,参数传递好办,直接用request.setAttribute(str1,str2); 但是如果不用Servlet 而是直接用jsp进行转发呢? 我们首先要知道   请求 ...

  7. 应用框架的设计与实现——.NET平台(10 授权服务.CodeAccessSecurityAttribute)

    以下内容转载自:http://blog.csdn.net/dongma_yifei/article/details/1533124 CodeAccessSecurityAttribute 是 Prin ...

  8. json原理和jquey循环遍历获取所有页面元素

    1.json原理: javascript object notation (javascript 对象表示法) 是一种轻量级的数据交换语言,由javascript衍生而出,适用于.NET java c ...

  9. c#中的static

    1.C# 不支持静态局部变量(在方法范围内声明的变量). 2.static类一般用于与状态无关的类.那么,什么是与状态无关的类?我的理解是当一个类中没有属性,只有方法的的时候,就可以认为这个类是与状态 ...

  10. ASP.NET MVC学习之视图篇(2)

    继ASP.NET MVC学习之视图(1)学习 4.HTML辅助器 虽然在ASP.NET MVC中我们已经摆脱了ASP.NET的控件,但是对于页面中需要循环标签的情况依然还是存在,可能很多人认为用for ...