1. import java.util.concurrent.locks.Condition;
   
2. import java.util.concurrent.locks.Lock;
   
3. import java.util.concurrent.locks.ReentrantLock;
   
4. 
   
5. public class ProducerConcumer {
   
6.         public static void main(String[] args) {
   
7.                 Res res = new Res();
   
8.                 Producer pro = new Producer(res);
   
9.                 Concumer con = new Concumer(res);
   
10.                 Thread t1 = new Thread(pro);
    
11.                 Thread t2 = new Thread(pro);
    
12.                 Thread t3 = new Thread(con);
    
13.                 Thread t4 = new Thread(con);
    
14.                 t1.start();
    
15.                 t2.start();
    
16.                 t3.start();
    
17.                 t4.start();
    
18.         }
    
19. }
    
20. 
    
21. class Res {
    
22.         private String name;
    
23.         private int count = 1;
    
24.         boolean flag = false;
    
25.         private Lock lock = new ReentrantLock();
    
26.         Condition condition_pro = lock.newCondition();
    
27.         Condition condition_con = lock.newCondition();
    
28. 
    
29.         public void set(String name) throws InterruptedException {
    
30.                 lock.lock();
    
31.                 try {
    
32.                         while (flag) {
    
33. 
    
34.                                 condition_pro.await();
    
35. 
    
36.                         }
    
37.                         this.name = name + "..." + count++;
    
38.                         System.out.println(Thread.currentThread().getName() + "生产者"
    
39.                                         + this.name);
    
40.                         flag = true;
    
41.                         condition_con.signal();
    
42.                 } finally {
    
43.                         lock.unlock();
    
44.                 }
    
45. 
    
46.         }
    
47. 
    
48.         public void out() throws InterruptedException {
    
49.                 lock.lock();
    
50.                 try {
    
51.                         while (!flag) {
    
52.                                 condition_con.await();
    
53.                         }
    
54. 
    
55.                         System.out.println(Thread.currentThread().getName() + "......."
    
56.                                         + this.name);
    
57.                         flag = false;
    
58.                         condition_pro.signal();
    
59.                 } finally {
    
60.                         lock.unlock();
    
61.                 }
    
62.         }
    
63. }
    
64. 
    
65. class Producer implements Runnable {
    
66.         private Res res;
    
67. 
    
68.         public Producer(Res res) {
    
69.                 this.res = res;
    
70.         }
    
71. 
    
72.         public void run() {
    
73.                 // TODO Auto-generated method stub
    
74.                 try {
    
75.                         res.set("");
    
76.                 } catch (InterruptedException e) {
    
77.                         // TODO Auto-generated catch block
    
78.                         e.printStackTrace();
    
79.                 }
    
80. 
    
81.         }
    
82. 
    
83. }
    
84. 
    
85. class Concumer implements Runnable {
    
86.         private Res res;
    
87. 
    
88.         public Concumer(Res res) {
    
89.                 this.res = res;
    
90.         }
    
91. 
    
92.         public void run() {
    
93.                 // TODO Auto-generated method stub
    
94.                 try {
    
95.                         res.out();
    
96.                 } catch (InterruptedException e) {
    
97.                         // TODO Auto-generated catch block
    
98.                         e.printStackTrace();
    
99.                 }
    
100.         }
     
101. 
     
102. }
     

复制代码

刘张朋 发表于 2013-7-19 23:28
你的代码没问题啊，每个线程任务都可以执行一次，你是不是觉得不能像视频里那样生产很多啊？如果是的话原因 ...

哦哦，是啊，就是出来四个。

你的代码没问题啊，每个线程任务都可以执行一次，你是不是觉得不能像视频里那样生产很多啊？如果是的话原因就是你在生产消费时都没加循环