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

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,iVBORw0KGgoAAAANSUhEUgAABHoAAACoCAIAAAAQFB4VAAAgAElEQVR4nO3d6XcU54Hv8for7qv7Zs49Z+459jj2dZyZqw7DxCF27MlM4puZyeqA78QUmQTsGGNiYxvZAQMJxmpsM15Qgg3a1VJrLaFdQhKrQEgsBgqkxiIGQcwmvMR4Ts+L7qp6quqp6mqpS2rQ93N+5yCVaumurkb166fUrSSTybMffUoIIYQQQgghJLdRqFuEEEIIIYQQEkaoW4QQQgghhBASSqhbhBBCCCGEEBJKMtQtrWOQEEIIIYQQQsgUIq9byWQy9eMkjF0xcvYqIYQQQgghhASPpG6lCsZsd5y8Q+MihBBCCCGEZBVJ3aJreaFxEUIIIYQQQoLHWbeSDG15o24RQgghhBByW+bpF9YmLn6S89U66xZdy5/WMTicuEoIIYQQQsiczaxXI2kOj17qHdjXvav/kH7enHjwxLmu3r6+PYPDY5enU7f2t/92f4cr7S8dPnWaupVL1C1CCCGEEDLXczaUDI3+ue/g8cFT5x3TD56e6Dv4wcHTE/6L9/TtPnb8+MmTJ7t6eg/q54fPXj3wwXh3zy5d148cPdozsM9/8adfWDt28ROvn+5rf3ny+kVHRnY+s6flhaFTp31WG6huHTpz9eHC3d9ePeCVR9bsGZv4dMa7zyzwr1sPLFk0+0c/IYQQQgght1oOnPhTvK6+sUmrrY0PDJ0yp+89kqiN16Wm7z2S8FlDW3tnIpEYHx/Xdb2zq2fPsN7Z1TM2NjY+Pp5IJNo6Ov1vwNPPrx2b+MTrp3vaX/nsL186onetHm5ZOaCtPnTytNeCgerWvJW7vqe++sjijV753pJN9z+3a8a7zyzQOgaHE1e88s3Hf5z6ovvwmR+s/LXPnIQQQgghhNyycZaKQ1rH/ice3//zH0jy1JKhnn0Z61bTzs6Wlpbe3t7Ozs6a2tr+QydTXaumNt7e3t7b29vW1lbX0OSzht2HPujq7jEbV3dPz+joaKprdXX37h05M5261bdz/Y3PvtxcuueVd7uffU1buHLHjc++HO1fr3e9eKjhyZ6m1dOqW/c90fGvj68Z+vimV360ZN19T3TMePdx6F6hrOjOZoH/MGScaPKvW3d/9/7UFyWt3d9WH831YT3y0j8oiypm/dlFCCGEEEKILXsW/evktrc/r6tw58o7m/ctezzjGuqbWlpaWrq6urq6utrb22M1NZ39g9WxmtbW1tTE1tbWmtq4/0r6B492dnWnGldKIpHo7OrZO6xnvAFPP79mbOKG1097td9d//TmR3/+5E8Xb4xPTCY+unr905tm2muf81owUN2691favy1eO/TxTa/e8qMl6+79lebxw+4ViiG7NpStqdStjF84+NStosaerz75m0deXl/RvS/y4+9Wd+7O9KCOvPQPimDZHwLMT90ihBBCCCH5lj3/9k+flW2b+OEP3fm8akffdxdkXMPeo4mq6uqWlpaOjo6Ojo7W1lb3t/1DJzOup3tgsK+//9SpU5qmNTc3d3V39x04kvrRwNDJuvqGlvaeoTN/di/oX7e6mjZevXFzc+mejdv61r7TtfqNtt9san5qff3PV5VfvXFzZ+x5rwUD1a17ltT99Jfrhz6+uXJDyy9fiC186v3vL37rwZ+8as6wcOnv7llSJ29AYsnqXvFQcSKbQpSVqdetpDGoJf2RyF23Hliy6FuLH73/0e/f8+sX6gbbH3v9+QUv/nb+qpd+ufUP72vdDz72g39csrBl/zHZ3rfXp4pliuLfpqhbhBBCCCEkH9P/vYc/eeuNC99+2J1Pi9/q+fY3gqxkz8hoZVWVpmltdi0tLZVVVX0HP8i4hv3Hzra2dYyOjjY0NHR2dnZ2dtbV1WktOwdPfjRw6ER9Q1Nvb29rW1tLR497Wf+61d646fLkFx9evHF2YvLshcnE+etj56+PfnTt9Lmrlye/aK5a7bVgoLp19+NVjz250Wd069+f2nT341Wuyd0rwh7Qcm4u661Ja5VX10omk1rH4OGxK2I6Dp3qOHSqY/DE3z713E9ee/Ibz32vdXhP46GelTvevXf584XbS/6zqv7/fP/Be/7lQceCh8dGCucri8qFKf2vR5Rlxc7ZvOcnhBBCCCFkxuMuFT0Pf2vy9xsuzP+mOzde29hx/7yAtW3PyGhFZWVTU9NOQ3Nzc0VlZZCute9oItW1xsfHY7FYV1dXd3d3e3t7PB6vb2iI19WbU+obtWzr1s76okvXvpCObl269kV9xUvTqlt3PVaiPv3a0Mc317/Vs/q1nSvX1T2xunLxyvcffeLdXzy7LZlM/uKZ6F2PlUjqj+dglnCFodWRulcoDxUXp39iLpoofkg2p3RxyQwZx9Pcf7vlM7O7bpl5Labdu/z5/aOD+sSJ8ctjR/50oLhnx91PruoYTngs4q5P4pTGRcZdiGwYEX5qTU/PKZY0W2Ez51xQuGGZMv/1ltl+ZhJCCCGEkNshCWe6Fnzz+osvXLjv6+5cf/ml1q8XuBeRZmD4THlFZX19vWZobGwsr6joHTyecdnmllbzvTEaGhtjsZr29vbUhYjxeDz1dVtbW228fs/RhHvx5c+vGZ244bXypvjmiatfjJ6/ceajyTN/mjx97rp+7vqp8Ws19TtLy6vKtv32cOJKQ8fAe6WVtS094oKB6tadP/vjr57dPPTxzctXP/34yieXLt+4+PHkxKXrFy5enfjztWQyuWzVG3f+7I+SSiXvOt0rxBZkjYEJlx4mih9KzZIofsg5ZuWzuPmFraz5j3nlpG5Vde154P//+M6lzx48u+/4R8ONh+J7R3s6Pqhb/M4rj6wr8jhSfepW4yJlQWG/Y+JI4XxFMdtU+bL01/K61bjI7GOpBalbhBBCCCEknHRF/v7ac6su/O/73Ln24outX/1akJUMDJ8pK6+Ix+ONdvX19WVl5b0Hjvsvru1sO3XqVCKRaG3rGBg62TlwMBaL7dy5U7woMVYT3z0yKl18+ao1oxM3vFbeEHv9/OW/uEe3CtcWFRcXb/z9uu2VdZtff7O4uHjrthJxwWB169Hip17c4nMx4dOFb935aLFzqlfdck43G5GjJqW+To1TCQv4LW78a+czwDX9iwkPj115QF0479F/2aF13f/C+s0t7w+e7Ws92rA2vrp8X/Gmlo1fWfqbu/5x3vxHH2nZd8y+oLRuLSjsT1Upm8iGEdf8xrfSulVuH84qZ3SLEEIIIYSElZ6vFkyuXXvhr+9zZ3LDhvY778m4ht0jYyWlZTU1NfX19fX19fF4vKysXPy2tLRs1+AHPmvYc2Ssoam5obG5/9CJ1JSmtu5YrKbFUF0d69l3xGtx/7pVW/3muY//cvLc5Inx6yc+vP7B2WvHz147lrha29RVVBTdsmXLq5s2bdmy5fcbN+3sOyQuGOxiwoV/eOblt597Zeuza9+VZvlLb9/779sy9irvvmQ2K3fdMr81epPf4q7W5mtqb5Xh3vsdh071Hz17eOzK+rL6O/5jRfn+7drRyre7Nz321g9Xx5/9q58vPzx2ZWud9q3Hf2pf0FW3zFIkb0fULUIIIYQQko/pvetvbxRFL9wdceeTN9/s/F9/k3ENsbqmqqqqeDwej8djsVhJSenOnr07Skqqq6tTE6urq8vKKzKt5/LQ6OXU17sGj1dWxZoEDQ0NFZXV+46fky7rX7eqK9/68NLnm0v3bPhDb+Gb7StfbVq2pvbDS59/eOnzt7e+t2HDhk2bNr3yyrryulbHgoHqlrb7dER9f96S9+YteW/ekm1fNzJvybbUxL//xfuDJ867F0wUP+QYmDIKk/1qwPQ3srqVKC7utlZmjl55LG5dlCj8FZfntYRTeyP4w2OXvfK1//fAz373xl1Ln3u6dO3mzvXLS5fd8aufP/FOReqnvSNj9vmHC+cri8qNb8uXKsqCwv7Ut6lLAdM/Kl68tNiYX1ncmJrYsmGBoiwtHrt8uH9zxFjQmmhbw3DhfEWZv7nF+5YTQgghhBASOM420nPn3914Y8unW4vdmXytqPe+b2SsW7UNWnl5eSwWq66u3rGjpGf/scNjVwaGz2zfsaOysjIWi1VWVpaWlQetfweOVVRWp0bG6urqKquqzFGy8oqqvcfGs61blWXvJC5+fvzD68fOXjuauHpk7OrImSuJi583t/f/ds3adevWvfzyy+vWrXt5zSud+2wXPQaqW8lk8tLVT89dmhy/OPnA8tgdP3ojlQefrjl3afLcpcnL1z/zaDQe72rh81YZrtEta9bMixtfy95ew21qH3M8NHbZK1/5529oe4+U7xqZ/5v1/+MnT/zPRb9e9nbF7pMXPOYfXj1fuF5w/uZm8af9myPGTxaWW/MvXLzUmLx0qzFz84YF6WsOFy+NmNOtNSxYvWGpc/2EEEIIIYRMKe42sn9T8cBff23/PfPc6b+j4MB7dRkL0t5j4ztKSiura3aUlHbvO2pO7z98evv2HeUVldt3lPhfTCimtKyitrY2Ho/X1NSUlVc2t+8qK09Pqa6urq6tz7ZuvffHotKSd915cfXzhYWFK1eu2LL1/RdXFxYWFr66eUvWdevml//10DO1d/z4Ta88/Ez88y++9Kw1txGtY3Bo9LJX/jNW/51fPJb6+v8+8h2fOWc6ZUuV+ZubZ/1mEEIIIYSQWz8hDZodOHm+Y+DQ3mMfOqbv/+Bc66797uk+KSuvqK6urq6uLi0rHxg+fXjscnvfgZLSslgsVllVVR1vdC+yfNWa0YlJrxXuO/6hNJvf2vrSmnW1O3sPj10urdHWbti4dXuVuGDQ0S2k+Net9sGT33r8p6mvv/KdBc27R2bvaTC8ev7SremvGxcqSmT98Kw/MwkhhBBCyO2Q2R5ey5i+w3ppeWVpeWXfYd2c2NY3WFJaVlFde+Dkefciy1etOTMxmfNbQt3Kjn/dOnj6UufQ6dTXG/64ff7PfrD/5MSsPQ36rMsR6VqEEEIIIYT4ZPmqNWcuTOZ8tdSt7PjXLUIIIYQQQggxQ93KDnWLEEIIIYQQEjDUrexQtwghhBBCCCEBQ93KjtYxSAghhBBCCCFBQt0CAAAAgFBQtwAAAAAgFNQtAAAAAAgFdQsAAAAAQkHdAgAAAIBQzIG6pRcVKAVFejKZ1FRF1Wb75kyDcfute5S96Sw7Z+X/IeT1sGqqMVkvKsjPmy7lcWuzOno51KWmeAjrRQWKzJSOKa+VZV6b763Xiwp4wAEA+cenbtl/JebjrzHrXDJN+us207myptp/0bvWmiN6UcEUT04Ms1a30rvIc7n0z13nS+5daTuo8vXs33XkT7FueRxJOTjAZEf+lOuWpvo9FtZj657F/Fmm+6MXFQgzCYdLaqr8OMmybgXeJ/nNuufCYSjsCo99Ln0QJY+dZ9GxZpJv1+v/Vvs2vY4l+wHgXs5nqusuec4TqG157yj5euV7I7tF3Du9oEgP6/cMACD/ZKhbYgfJv7Njn7olPV3zrFsZOkJO6EUFBQXTG2CY8tBKLkY2vHaL47RDU8W5XCdAwoT8PRv22V3ZPQTy879cHGBBX8fPULdSZ8Gq6tPEPDcjPH4Z/ndIH/pi3XK3K3dVyvaIvR3GNqz7IDyR7A3Mtc89HkTpY2d7ekp3mHS7XjOLBcnnWHIeAOHULVuLd5Ybz1vo/xTwfBSyXMR+L6313PIHLAAgiKB1Ky+vorqV6lbqpk1vL+Zh3cpUw51nFLbv8/X13ZzVLa8T2hzc7YCnaoEuJvT6ke82nOfinvvFPPJ96pbsOMn+iL31T189Di/jjvntc/e30iNPXH3G/SXOEPBiQskD5z4Awqhb9v+J7K/6ZLqFwY43x+6awiKuxfLxtyoAIPcC1i3HSIT1OqLst7FtSMw50blW6/VCVdNUa43uTUinSOuWsN30lWCprWRft5z3yrYfrG+8Ljhx3bKk86TDuNeSfeSeLl5MKNnJ4mu4woJee8PjAUrdxCLV8fh6vVgubw72XeN1Fmgs7ffo2/eocCVVkaNICItLHg5NVQqKtPR0VbPWJLv5rhMp+SEU5FkgOyfLzQFmX7Pnw6rY95KwUY+FbffaOhBcO8r+tPGskLIDX3btqbQ8uJ4CtgfCfZR675Op7mfhZgvn85J76zwYdOHSYfuSHvtT3FlOxr722+eu++567PSiAlXzak3SWyRuL+PoluxmJOUHgGd3y1w+XENY5n2z3brp1S3Hrztr046ymu0iScmDdou/QAAACCLg326JvxOcZ4uqJv0VpqmOk3V3VXBcnmE/X3T9aYL7Eo1go1tTr1t6kSqeITq2aa5XNpt7G1aRcJxrC41Aujes6e665d5R0hvjtTdkD5B4daB4DjHFuuXYv8L5hfMk1+PRt98w2+mzrV8K54WSPSCUsdQJm3cbcpwMFhTpskMo4LPA/4xregeY42RYspfEXWnM4T5kvOqWeJmo62zSsYzHgeCoR5KzdVsJs5+9Sp4C9rspP0ol+2Tq+1ncYEFBgXkEBfjfyZjq/dwPcKzYFvPd5/Yfej52uv3yP7+T/QDNIGPd8jgAQhjdcs6W67ol+2WT7SLuSQxvAcCcEGh0y3UG5355MTXVPgAmPT3zG93yWtZno6HWLWNp2yuv9iEZz9mcmxDPKuUvxounffLprrrlc5JruzGyveH1ADlPCqdUt5wz2U6BXR3e/9EXeoK89UvOn/xGKTy/du8K9wRhnCHIs8B59yXbnMYBJqzZ62F17CVV+nKAd93yeUIHGN0S1+txpDgeC0lVsn0rP3sXm4Bsn5jfTWE/W0dfQZGeOol3FQ+PERfn8eA5m7Bt1z5y/t8bvG7JH7ugdcv1wpHXgJRf3fI8AHJdt1y71sU+spahbknX7/xxThZheAsA5oSAFxMKvzv8zrBTv5KlVUiX/PlBVnVLslHXby/pKXiWdcsx5OZeX2oj9mbnc+aflJ0MSMdWclG35DcmYN1yv3afqW4F7lvC2V6meuN1wwLWLfkeCKFuBXkWyLaRwwNMsg9895Jif8MCz/trTvavWwFOYTOcnNvXkvmViMx1Sz5qNY39rKf/8sgsWprrEPY8GFx1K8NzRfLKj22C3z53PQucj50meTh8aqLkkZIWdZ+65X0A5LpuSWabzuiWa5MeT48sF5EswegWAMwJQd8qQy+Svw2ZpqZPaIokL7PLzqSEFelFBR7FQ9yEVmSMGzg3aluDY4tTrlv2OyquTjyLKFBVWQ+x3x7ZvbF971yr7WJCyXRX3XLvKPmN8dob0lPdrOqW7Rw1NVv6vFR+IVKAuuV3w+x7JUMFcey6nNatoM8C517M8QFmrll+SMj2kuQYdfdV6XPVfLnEuckgpVuYxXz6Oh5px3EiewoEqFuSfTK9/awLbyma+tq5Tzz+dzLrnN//nF47yfkUsiZ67HNJ+3LdTgfPJ6P8dZVABcmzhIQ6uiWZbTp1S/oU8F9PgEUkzxK/ygYAuH0EfmdCVx1wvFptjeDYznwlL2ubSwtvpSs9wbUvKNuoYxvOMQQlu7fK0FSvW+p411/HGavXbMIttE8zpuhF6eu7HHfLa7q7brl3lPzGyPaG1wOUXd2Sr8Z5yiGeAgcZXZEfOeKdc71Vhmwmaw/kvG4FfxZY9zqEA0yXDBpbN8JrL2nGn685xx+Mo1LcP/Y7JP7U/ST15hzGMm6g6/RTqErup0CQuiXZJ9Pbz47uZbv77l3hfjEjw/+cjr1ktSkbn30uexDtq/B4eGRPRvl2vZ78msd1wpKNukbmpEKtW9Jb6PsUkO+NKSzi0cIY3AKAucGnbs0Vs/crz+u1zbx8zTPQZYOecn+Xpnd7Zlh4j2h6zXl5yExBTu7HLbxPpC9HzPrGXOUlm6LtseXAo1vuS7EDdDSf0a38MaMPNgBgFlG33GMOM+aWqVvpXTStc4Ppt1rxbMx5GVreC6/Ua6qiFnlf8zSDnCfGU7rDOdlR+bNPspZ3T36E45Z6vQgAMC3UrVl0y9StfCFcxcOZStrsvVqQv9gnAAAgb1C3AAAAACAUnnXrPQAAAADANDC6BQAAAAChoG4BAAAAQCioWwAAAAAQCuoWAAAAAIRiBuuWHo3w1swAAAAA5oy5Wbf0aITP5QEAAAAQrjlYtzRViUT1fLk1AAAAAG5XGeuWpipqNDUYpCiRqC6ZatYW3ZwiNBlhojFZU22LWPNqquJcgWyd8q0bywcrUdQtAAAAAOEKUreMBqNHI0bh0lSre6XLk/BT4WtNNfuPVXDkdUuYVdy6WLK8t+66sZlQtwAAAACEK9DoltFKpIXJ9TNxMasiZaxb4qziSkVW3Zp2U6JuAQAAAAhXftct2TTp1rNH3QIAAAAQrmzqlnC1n6TwSC8mtCamBqoczUqcqEcj0osJJaXIs25xMSEAAACAvBHsb7fs1/IlvQqPNa81p3k9oKpZC5kTI9GoY/TM560y5H+v5boBmUqUeI94O3gAAAAAYcnqYkIAAAAAQFDULQAAAAAIBXULAAAAAEKRsW4BAAAAAKaCugUAAAAAoaBuAQAAAEAoZrBu8UlXAAAAAOaSOVm3rM/ysj4fDAAAAAByaw7WLT0aET5tmcIFAAAAIByB3gg+aowGmd3ENtUsUdaokdCrhInGZOHN5e0dTFMV5wpk65Rv3Vg+i0qnqVnNDgAAAADBBalbRiURBoM01epe6fIkDhVZXwuFxmpW8rol6z7ip35pqs/WXTc2iHwZbwMAAABwO8rqY46lhcn1M3ExqyJlrFvirOJKRVbdykFLYmgLAAAAQJjyu27Jpkm3ni09GqFrAQAAAAhVNnVLGA6SFB7pxYTWxNRAlaNZiROlDUg+AuVZt4JdTEjXAgAAADADgv3tlutt0+WFx5rXmtO8HlDVrIV06703oo7RM5+3ypD/vZbrBmQoUs4LFCleAAAAAEKR1cWEAAAAAICgqFsAAAAAEArqFgAAAACEImPdAgAAAABMBXULAAAAAEJB3QIAAACAUMxg3XJ8EDIAAAAA3NbmYt0SPkrM+nwwAAAAAMituVi3THo0QuECAAAAEJJAbwQfjUYcg0G2qWaJ0s0pQq8SJhqThTeXt3cwYdzJb53yrRvLB690+VcAAQAAANw+gtQto8EIg0GaanWvdHkSh4qsrzXV7D9WuZHXLWFWcetiyfLeuuvG+jJqHUNbAAAAAEKT1cccSwuT62fiYlZFyli3xFnFlYqsupWbQSlZwwMAAACAnMjvuiWbJt36VHlsAAAAAACmLZu6JYwFSQqP9GJCa2JqoMrRrMSJejQivZhQ0qw861aWf7tF2wIAAAAQnmB/u+V623R54bHmteY0rwdUNWsh3Xrvjahj9MznrTLkf6/lugGZ6hbvAw8AAABgJmR1MSEAAAAAICjqFgAAAACEgroFAAAAAKHIWLcAAAAAAFNB3QIAAACAUFC3AAAAACAU1C0AAAAACMWcrFvWZ3nxwVsAAAAAwjIH65YejQiftkzhAgAAABCOQHVLUxWD8abw1gCROUlTFTVqTLZajDCnMVF4c3k9GlFULZnUo5FINKoqipL+RxEqkWND9i2J71OvqfbvM9HUrGYHAAAAgOAy1y1JJRFHhayvha4jLCP73C553VIUVUtqqqJEoroejUSiun1pTTU2mp7Jvf4s65axcQAAAADIvSAfc+y83s7RUozCIylRSXN0ytZqPOqWqpmbS9ctYWhLHB7LzUcvM7QFAAAAIEyh1y1rJkU24uVftyQbdyw/RcZgGgAAAACEJWPdkhUTz4sJveuWbaLZolKjV951y2MEyrNuBbuYkK4FAAAAYAYEeasM8ZI+4X0xnO+lLq1btssBzYqjW++oEVX96pZ9BdK/1xIFqVvOCxQpXgAAAABCMQffCB4AAAAAZgJ1CwAAAABCQd0CAAAAgFBQtwAAAAAgFNQtAAAAAAgFdQsAAAAAQkHdAgAAAIBQzM26lf7sLT5xCwAAAEB45mDdSn2SsvVJzAAAAAAQhkB1S1MVg9FQ0uND4iRNVdSoMTkS1ZOuOY2Jmmpbj6olk3o0EolGVUVR0v8Yc0g2ZN+SWJo0NfCYFXULAAAAQLgy1y1NdTUYPRoxq5P1tdB1hGWEaiWuUlK3FEXVkpqqpMeeIlHdvnRqVMpYvaS6UbcAAAAA5JGMdcsqOSZHUzEKj6REJeV/JuVRt1TN3Fy6bglDW+LwmKzCZYu6BQAAACBcodctayZFNuLlX7ckG3csP2XULQAAAADhyli3jKv8nNOkFxN61y3bRLNFpUavvOuW7ErGpE/d4mJCAAAAAHkjyFtliJf0Ce+L4Xj/C3ndsl0OaNYbc2okGlX96pZ9BdK/1xIFqlvCG38432oDAAAAAHJmDr4RPAAAAADMBOoWAAAAAISCugUAAAAAoaBuAQAAAEAoqFsAAAAAEArqFgAAAACEgroFAAAAAKGYk3XL+iwv80PDAAAAACDH5mDd0lTzo42tj2MGAAAAgBwLVLc0VTEY5cQaIDInaaqiRo3J1rCRMKcxUVNt61G1ZFKPRiLRqKooSvofsRE5NmTfktiXNNX+vYymmrcjtW76FgAAAIAwZK5bwmCQQY9GbJUl9bXQdYRlhGolrlJStxRF1ZKaqiiRqK5HI5Gobl/a6knpmdzrD1C3zAGt1EqiKhcUAgAAAAhFxrqlufuI4xI8o/BISlTSHJ2ydSCPuqVq5ubSdUsY2hKHx2QVLqjUhsw+KLl7AAAAAJALodctayZFNuLlX7c8ytB06lbqlohjc1xMCAAAACAMGeuWcZWfc5r0YkLvumWbaLYo64+n5HVLdiVj0qduBfnbLbHDyVcPAAAAADkQ5K0yxEv6hPfFcL6XurRu2S4HNJuNOTUSjap+dcu+Aunfa4kC1S3eCB4AAADATJiDbwQPAAAAADOBugUAAAAAoaBuAQAAAEAoqFsAAAAAEArqFgAAAACEgroFAAAAAKGgbgEAAABAKKhbAAAAABAK6hYAAAAAhIK6BQAAAAChoG4BAAAAQIpCdRwAAACaSURBVCioWwAAAAAQCuoWAAAAAISCugUAAAAAoaBuAQAAAEAoqFsAAAAAEArqFgAAAACEgroFAAAAAKGgbgEAAABAKKhbAAAAABAK6hYAAAAAhIK6BQAAAAChoG4BAAAAQCioWwAAAAAQCuoWAAAAAISCugUAAAAAoaBuAQAAAEAoqFsAAAAAEArqFgAAAACEgroFAAAAAKH4b0Y5/G7S0XGbAAAAAElFTkSuQmCC" alt="" />

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

aaarticlea/png;base64,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" 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都是对一个对象进行操作,但这三个都是用在了资源池的类里面,所以,这也是资源池有且只能有一个的原因。

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

最新文章

  1. SQL Server触发器
  2. JAVAWEB项目实现验证码中文、英文、数字组合
  3. display:inline; display:block;
  4. Android 图片的合成
  5. 【转载】C++ function、bind和lambda表达式
  6. SharePoint加K2,将Portal系统与BPM系统完美整合!
  7. yum源的更新问题
  8. 一 手游开发工具cocos2d-x editor初识
  9. 51. leetcode 530. Minimum Absolute Difference in BST
  10. java 实现加密算法(在网上看的,保存)
  11. synchronized和Lock复习
  12. 初学JDBC的一些总结(一)
  13. Spark记录-Spark性能优化(开发、资源、数据、shuffle)
  14. 口语详解|为什么&ldquo;how to say&rdquo;是错的?
  15. Jenkins+Jmeter+Ant自动化集成及邮件正文以html输出
  16. maven指定本地仓库
  17. 第二周leetcode
  18. JS-得到屏幕宽高、页面宽高
  19. [洛谷P2577] [ZJOI2005]午餐
  20. Quartz与Spring的整合使用

热门文章

  1. RVM 实用指南
  2. C++中new和malloc的区别
  3. yield学习续:yield return迭代块在Unity3D中的应用——协程
  4. 为何重写toString方法后会使哈希码能够打印出来
  5. 【洛谷P1080】国王游戏
  6. 用JQuery的Ajax对表进行处理的一些小笔记
  7. Java 第14章 字符串
  8. msyql 数据库恢复相关
  9. Codeforces #259 Div.2
  10. [Leetcode][JAVA] Best Time to Buy and Sell Stock I, II, III