1. import java.util.concurrent.locks.*;
   
2. 
   
3. public class Test23 {
   
4.         public static void main(String[] args) {
   
5.                 Resource r = new Resource();
   
6.                 String x = "黄焖鸡";
   
7. 
   
8.                 PutX px = new PutX(r, x);
   
9.                 TakeX tx = new TakeX(r, x);
   
10.                 Thread t0 = new Thread(px);
    
11.                 Thread t1 = new Thread(px);
    
12.                 Thread t2 = new Thread(tx);
    
13.                 Thread t3 = new Thread(tx);
    
14. 
    
15.                 t0.start();
    
16.                 t1.start();
    
17.                 t2.start();
    
18.                 t3.start();
    
19.         }
    
20. }
    
21. 
    
22. class Resource {
    
23. 
    
24.         Lock lock = new ReentrantLock();
    
25.         Condition full = lock.newCondition();
    
26.         Condition empty = lock.newCondition();
    
27. 
    
28.         private String[] item = new String[400];
    
29.         private int taker = 0;
    
30.         private int puter = 0;
    
31.         private int count = 0;
    
32. 
    
33.         public void put(String x) {
    
34.                 while (true) {
    
35.                         lock.lock();
    
36.                         //用while不用if是因为当多个线程在这里等待后，被唤醒，需要重新判断这个条件
    
37.                         while (count == item.length) {
    
38.                                 try {
    
39.                                         full.await();
    
40.                                 } catch (InterruptedException e) {
    
41.                                 }
    
42.                         }
    
43.                         item[puter] = x;
    
44.                         System.out.println(Thread.currentThread().getName() + "..." + count
    
45.                                         + "...put.." + x);
    
46.                         if (puter == item.length - 1) {
    
47.                                 puter = -1;
    
48.                                 empty.signalAll();
    
49.                         }
    
50.                         ++count;
    
51.                         ++puter;
    
52.                         lock.unlock();
    
53.                 }
    
54.         }
    
55. 
    
56.         public void take(String x) {
    
57.                 while (true) {
    
58.                         lock.lock();
    
59.                         while (count == 0) {
    
60.                                 try {
    
61.                                         empty.await();
    
62.                                 } catch (InterruptedException e) {
    
63.                                 }
    
64.                         }
    
65.                         x = item[taker];
    
66.                         System.out.println(Thread.currentThread().getName() + "..."
    
67.                                         + (count - 1) + "..take......" + x);
    
68.                         if (taker == item.length - 1) {
    
69.                                 taker = -1;
    
70.                                 full.signalAll();
    
71.                         }
    
72.                         --count;
    
73.                         ++taker;
    
74.                         lock.unlock();
    
75.                 }
    
76.         }
    
77. }
    
78. 
    
79. class PutX implements Runnable {
    
80.         Resource r;
    
81.         String x;
    
82. 
    
83.         PutX(Resource r, String x) {
    
84.                 this.r = r;
    
85.                 this.x = x;
    
86.         }
    
87. 
    
88.         public void run() {
    
89.                 r.put(x);
    
90.         }
    
91. }
    
92. 
    
93. class TakeX implements Runnable {
    
94.         Resource r;
    
95.         String x;
    
96. 
    
97.         TakeX(Resource r, String x) {
    
98.                 this.r = r;
    
99.                 this.x = x;
    
100.         }
     
101. 
     
102.         public void run() {
     
103.                 r.take(x);
     
104.         }
     
105. }
     

复制代码

没搞懂你要表达什么

不能理解你的问题在哪