看完视频后总结，
第一种方法

1. package org.heima1;
   
2. 
   
3. public class Test7 {
   
4. 
   
5.         /**
   
6.          * 生产者消费者问题
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 Resource r=new Resource();
   
10.                 productor p=new productor(r);
    
11.                 consumer c=new consumer(r);
    
12.                
    
13.                 Thread t1=new Thread(p);
    
14.                 Thread t2=new Thread(p);
    
15.                 Thread t3=new Thread(c);
    
16.                 Thread t4=new Thread(c);
    
17.                 t1.start();
    
18.                 t2.start();
    
19.                 t3.start();
    
20.                 t4.start();
    
21.         }
    
22. 
    
23. }
    
24. class Resource{
    
25.         private String name;
    
26.         private int count=0;
    
27.         private Boolean flag=false;
    
28.        
    
29.         public synchronized void set(String name){
    
30.                 while(flag){  //必须用while循环判断，如果用if，就会出现极端情况
    
31.                         try {
    
32.                                 wait();
    
33.                         } catch (InterruptedException e) {
    
34.                                 // TODO Auto-generated catch block
    
35.                                 e.printStackTrace();
    
36.                         }                       
    
37.                 }
    
38.                 this.name=name+"----"+count++;
    
39.                 System.out.println(Thread.currentThread().getName()+"。。。生产者。。。"+this.name);
    
40.                 flag=true;
    
41.                 notifyAll();//必须用notifyAll，防止只唤醒自己的线程
    
42.         }
    
43.         public synchronized void out(){
    
44.                
    
45.                 while(!flag){  //必须用while循环判断，如果用if，就会出现极端情况
    
46.                         try {
    
47.                                 wait();
    
48.                         } catch (InterruptedException e) {
    
49.                                 // TODO Auto-generated catch block
    
50.                                 e.printStackTrace();
    
51.                         }                       
    
52.                 }
    
53.                 System.out.println(Thread.currentThread().getName()+"。消费者。。"+this.name);
    
54.                 flag=false;
    
55.                 notifyAll();//必须用notifyAll，防止只唤醒自己的线程
    
56.         }
    
57. }
    
58. class productor implements Runnable{
    
59.         private Resource r;
    
60.         productor(Resource r){
    
61.                 this.r=r;
    
62.         }
    
63.         public void run(){
    
64.                 while(true){
    
65.                         r.set("商品");
    
66.                 }
    
67.         }
    
68. }
    
69. class consumer implements Runnable{
    
70.         private Resource r;
    
71.         consumer(Resource r){
    
72.                 this.r=r;
    
73.         }
    
74.         public void run(){
    
75.                 while(true){
    
76.                         r.out();
    
77.                 }
    
78.         }
    
79. }
    

复制代码

第二种方法解决

1. package org.heima1;
   
2. 
   
3. import java.util.concurrent.locks.Condition;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. public class Test8{
   
8. 
   
9.         /**
   
10.          * 生产者消费者问题,利用Lock解决
    
11.          */
    
12.         public static void main(String[] args) {
    
13.                 Resource1 r=new Resource1();
    
14.                 productor1 p=new productor1(r);
    
15.                 consumer1 c=new consumer1(r);
    
16.                
    
17.                 Thread t1=new Thread(p);
    
18.                 Thread t2=new Thread(p);
    
19.                 Thread t3=new Thread(c);
    
20.                 Thread t4=new Thread(c);
    
21.                 t1.start();
    
22.                 t2.start();
    
23.                 t3.start();
    
24.                 t4.start();
    
25.         }
    
26. 
    
27. }
    
28. class Resource1{
    
29.         private String name;
    
30.         private int count=0;
    
31.         private Boolean flag=false;
    
32.         private Lock lock=new ReentrantLock();
    
33.         private Condition con1=lock.newCondition();
    
34.         private Condition con2=lock.newCondition();
    
35.        
    
36.         public  void set(String name){
    
37.                 lock.lock();
    
38.                 try {
    
39.                         while(flag){  //必须用while循环判断，如果用if，就会出现极端情况
    
40.                                 try {
    
41.                                         con1.await();
    
42.                                 } catch (InterruptedException e) {
    
43.                                         // TODO Auto-generated catch block
    
44.                                         e.printStackTrace();
    
45.                                 }                       
    
46.                         }
    
47.                         this.name=name+"----"+count++;
    
48.                         System.out.println(Thread.currentThread().getName()+"。。。生产者。。。"+this.name);
    
49.                         flag=true;
    
50.                         con2.signal();//唤醒对方的一个线程
    
51.                 } catch (Exception e) {
    
52.                         // TODO Auto-generated catch block
    
53.                         e.printStackTrace();
    
54.                 }finally{
    
55.                         lock.unlock();
    
56.                 }
    
57.         }
    
58.         public void out(){
    
59.                 lock.lock();
    
60.                 try {
    
61.                         while(!flag){  //必须用while循环判断，如果用if，就会出现极端情况
    
62.                                 try {
    
63.                                         con2.await();
    
64.                                 } catch (InterruptedException e) {
    
65.                                         // TODO Auto-generated catch block
    
66.                                         e.printStackTrace();
    
67.                                 }                       
    
68.                         }
    
69.                         System.out.println(Thread.currentThread().getName()+"。消费者。。"+this.name);
    
70.                         flag=false;
    
71.                         con1.signal();
    
72.                 } catch (Exception e) {
    
73.                         // TODO Auto-generated catch block
    
74.                         e.printStackTrace();
    
75.                 }finally{
    
76.                         lock.unlock();
    
77.                 }
    
78.         }
    
79. }
    
80. class productor1 implements Runnable{
    
81.         private Resource1 r;
    
82.         productor1(Resource1 r){
    
83.                 this.r=r;
    
84.         }
    
85.         public void run(){
    
86.                 while(true){
    
87.                         r.set("商品");
    
88.                 }
    
89.         }
    
90. }
    
91. class consumer1 implements Runnable{
    
92.         private Resource1 r;
    
93.         consumer1(Resource1 r){
    
94.                 this.r=r;
    
95.         }
    
96.         public void run(){
    
97.                 while(true){
    
98.                         r.out();
    
99.                 }
    
100.         }
     
101. }

复制代码

哦   这代码写的   哪个多啊    绝对牛掰   虽然我现在还看不懂

菜鸟的求学路 发表于 2015-5-22 00:11
哦   这代码写的   哪个多啊    绝对牛掰   虽然我现在还看不懂

:'(这是基础视频上教的代码，只是感觉很好，就顺道敲下来了