程序是想实现，多个生产者，多个消费者，资源有多个（通俗来讲，仓库中可以存放多个产品，以往的程序只是一个），程序如下，实在不知道哪里错了。求高手解答！

1. package com.bocsoft.study;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.concurrent.locks.Condition;
   
5. import java.util.concurrent.locks.Lock;
   
6. import java.util.concurrent.locks.ReentrantLock;
   
7. 
   
8. public class ProduceConsume {
   
9. 
   
10.         public static void main(String[] args) {
    
11.                 Resource r = new Resource();
    
12.                 Produce p1 = new Produce(r,"苹果");
    
13.                 Produce p2 = new Produce(r,"香蕉");
    
14.                 Produce p3 = new Produce(r,"橘子");
    
15.                 Consume c = new Consume(r);
    
16.                 Thread t1 = new Thread(p1,"苹果生产者");
    
17.                 Thread t2 = new Thread(p2,"香蕉生产者");
    
18.                 Thread t3 = new Thread(p3,"橘子生产者");
    
19.                 Thread t4 = new Thread(c,"消费者1号");
    
20.                 Thread t5 = new Thread(c,"消费者2号");
    
21.                 t1.start();
    
22.                 t2.start();
    
23.                 t3.start();
    
24.                 t4.start();
    
25.                 t5.start();
    
26.         }
    
27. 
    
28. }
    
29. 
    
30. class Resource {
    
31.         ArrayList<Food> al = new ArrayList<Food>();// 仓库中可以存放多个产品
    
32.         int max = 5;// 定义最多存放的产品数量
    
33.         Lock lock = new ReentrantLock();// 创建锁对象
    
34.         Condition p_condition = lock.newCondition();// 生产者使用的Condition
    
35.         Condition c_condition = lock.newCondition();// 消费者使用的Condition
    
36. 
    
37.         void put(Food food) {
    
38.                 lock.lock();// 获取锁
    
39.                 try {
    
40.                         while (!(al.size() < max))
    
41.                                 // 若资源已满则等待消费者消费
    
42.                                 try {
    
43.                                         p_condition.await();
    
44.                                 } catch (InterruptedException e) {
    
45.                                         e.printStackTrace();
    
46.                                 }
    
47.                         // 未满则生产产品
    
48.                         al.add(food);// 将产品添加进产品库
    
49.                         System.out.println(Thread.currentThread().getName() + "生产了产品：----------" + food);
    
50.                         c_condition.signal();// 唤醒消费者消费
    
51. 
    
52.                 } finally {
    
53.                         lock.unlock();// 如遇异常，锁必须释放
    
54.                 }
    
55.         }
    
56. 
    
57.         void get() {
    
58.                 lock.lock();// 获取锁
    
59.                 try {
    
60.                         while (al.size() == 0)//若无资源消费则等待
    
61.                                 try {
    
62.                                         c_condition.await();
    
63.                                 } catch (InterruptedException e) {
    
64.                                         e.printStackTrace();
    
65.                                 }
    
66.                         Food food = al.remove(0);//消费一个产品，这里为了方便起见，每个消费者都消费数组中的第一个元素
    
67.                         System.out.println(Thread.currentThread().getName() + "消费了产品：----------" + food);
    
68.                         p_condition.signal();
    
69.                 } finally {
    
70.                         lock.unlock();// 如遇异常，锁必须释放
    
71.                 }
    
72.         }
    
73. }
    
74. 
    
75. class Produce implements Runnable {
    
76.         Resource r;
    
77.         String name;//生产的产品的名称
    
78.         Produce(Resource r,String name) {
    
79.                 this.r = r;
    
80.                 this.name = name;
    
81.                
    
82.         }
    
83. 
    
84.         public void run() {
    
85.                 Food food = new Food(name);
    
86.                 r.put(food);
    
87.         }
    
88. }
    
89. 
    
90. class Consume implements Runnable {
    
91.         Resource r;
    
92. 
    
93.         Consume(Resource r) {
    
94.                 this.r = r;
    
95.         }
    
96. 
    
97.         public void run() {
    
98.                 r.get();
    
99.         }
    
100. }
     
101. 
     
102. class Food {
     
103.         String name;
     
104. 
     
105.         Food(String name) {
     
106.                 this.name = name;
     
107.         }
     
108. 
     
109.         @Override
     
110.         public String toString() {
     
111.                 return name;
     
112.         }
     
113. }

复制代码

        public void run() {
               while(true)
                r.get();
        }
        public void run() {
                Food food = new Food(name);
                while(true)
                r.put(food);
        }