有趣的生產者消費者問題

轉載請註明出處：http://blog.csdn.net/sunyujia/

論壇上的網友提出的問題，每生產3個只能消費2個，感覺不是很難於是動手操之，為了省事

在原來的http://blog.csdn.net/sunyujia/archive/2008/05/02/2362015.aspx 基礎上修改的。

唯一的痛點在於生產3個的線程不是同一線程。消費2個的線程不是同一線程。就是說不能是一個線程連續生產3個，一個線程連續消費2個，如果是一個線程連續生產的話，程式就沒意思了。

1. import java.util.ArrayList;
2. import java.util.List;
3. import java.util.concurrent.ExecutorService;
4. import java.util.concurrent.Executors;
6. /**
7.  * 有趣的生產者消費者問題
8.  * 每產生3個消費2個
9.  * @author: sunyujia
10.  * @blog: http://blog.csdn.net/sunyujia/
11.  * @mail: sunyujia@sunyujia@yahoo.cn
12.  */
13. public class ExecutorServiceTest {
14.     private static int produceCount = 0;
15.     private static int consumeCount = 0;
16.     private static Object produceLock = new Object();
17.     private static Object consumeLock = new Object();
19.     public static void main(String[] args) {
20.         final List tasks = new ArrayList();
21.         System.out.println("MyBlog: http://blog.csdn.net/"+"sunyujia/");
22.         final ExecutorService exec = Executors.newCachedThreadPool();
23.         for (int i = 0; i < 10; i++) {//10個生產者
24.             exec.execute(new Runnable() {
25.                 public void run() {
26.                     while (!Thread.interrupted()) {
27.                         try {
28.                             synchronized (consumeLock) {
29.                                 if (produceCount >= 3)
30.                                     consumeLock.wait();
31.                             }
32.                             synchronized (produceLock) {
33.                                 if (produceCount < 3) {
34.                                     tasks.add(new Object());// 生產
35.                                     System.out.println(Thread.currentThread().getName()+"生產任務 還剩：" + tasks.size());
36.                                     produceCount++;
37.                                     if (produceCount >= 3) {
38.                                         consumeCount = 2;// 提示只能消費2個
39.                                         System.out.println("生產者友情提示現在庫存"
40.                                                 + tasks.size());
41.                                         produceLock.notifyAll();
42.                                     }
43.                                     Thread.yield();
44.                                 }
45.                             }
46.                             Thread.sleep(600);// 讓程式執行慢點以便觀察
47.                         } catch (InterruptedException e) {
48.                             e.printStackTrace();
49.                         }
50.                     }
51.                 }
52.             });
53.         }
54.         for (int i = 0; i < 20; i++) {//20個消費者
55.             exec.execute(new Runnable() {
56.                 public void run() {
57.                     while (!Thread.interrupted()) {
58.                         try {
59.                             synchronized (produceLock) {
60.                                 if (consumeCount <= 0)
61.                                     produceLock.wait();
62.                             }
63.                             synchronized (consumeLock) {
64.                                 if (consumeCount > 0) {
65.                                     tasks.remove(0);// 消費
66.                                     System.out.println(Thread.currentThread().getName()+"處理任務 還剩："
67.                                             + tasks.size());
68.                                     consumeCount--;
69.                                     if (consumeCount <= 0) {
70.                                         produceCount = 0;// 要求再產生3個
71.                                         System.out.println("消費者友情提示現在庫存"
72.                                                 + tasks.size());
73.                                         consumeLock.notifyAll();
74.                                     }
75.                                 }
76.                             }
77.                             Thread.sleep(600);// 讓程式執行慢點以便觀察
78.                         } catch (InterruptedException e) {
79.                             e.printStackTrace();
80.                         }
81.                     }
82.                 }
83.             });
84.         }
85.         exec.shutdown();
86.     }
87. }

執行結果如下：
pool-1-thread-1生產任務 還剩：1
pool-1-thread-2生產任務 還剩：2
pool-1-thread-4生產任務 還剩：3
生產者友情提示現在庫存3
pool-1-thread-11處理任務 還剩：2
pool-1-thread-12處理任務 還剩：1
消費者友情提示現在庫存1
pool-1-thread-5生產任務 還剩：2
pool-1-thread-6生產任務 還剩：3
pool-1-thread-7生產任務 還剩：4
生產者友情提示現在庫存4
pool-1-thread-14處理任務 還剩：3
pool-1-thread-16處理任務 還剩：2
消費者友情提示現在庫存2
pool-1-thread-3生產任務 還剩：3
pool-1-thread-2生產任務 還剩：4
pool-1-thread-4生產任務 還剩：5
生產者友情提示現在庫存5