有趣的生产者消费者问题

转载请注明出处：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