package cn.fuxi12;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//新特性生产者消费者


class ziYuanb
{
        private String name;
        private int jiShu = 0;
        private boolean bl = false;
        private Lock lock = new ReentrantLock();

        
        private Condition sheng = lock.newCondition();
        private Condition xiao = lock.newCondition();
        
        
        public  void shengc(String name)throws InterruptedException
        {
                lock.lock();
               
               
                try
                {
                        while(bl)
                                sheng.await();  //1   2
                        
                        this.name = name+".."+jiShu++;
        
                        System.out.println(Thread.currentThread().getName()+",,,,,,,生产者"+this.name+jiShu);
                        
                        bl = true;
                        sheng.signal();
                }
                finally
                {
                        lock.unlock();
                }
        }
        public void xiaoc() throws InterruptedException
        {
                lock.lock();
                try
                {
                        while(!bl)
                                xiao.await(); //3
                        System.out.println(Thread.currentThread().getName()+".....消费者"+this.name+jiShu);
                        bl = false;
                        xiao.signal();
                }
                finally
                {
                        lock.unlock();
                }
        }
}

class shengChanZhe implements Runnable
{
        private ziYuanb zy;
        shengChanZhe(ziYuanb zy)
        {
                this.zy = zy;
        }
        public void run()
        {
                while(true)
                {
                        try
                        {
                                zy.shengc("+煎饼果子");
                        } catch (InterruptedException e)
                        {
                                
                        }
                }
        }
}

class xiaoFeiZhe implements Runnable
{
        private ziYuanb zy;
        xiaoFeiZhe(ziYuanb zy)
        {
                this.zy = zy;
        }
        public void run()
        {
                while(true)
                {
                        try {
                                zy.xiaoc();
                        } catch (InterruptedException e) {
                        
                        }
                }
        }
}


public class Demo06 {
        public static void main(String[] args) {
                ziYuanb zy = new ziYuanb();
               
                shengChanZhe sh = new shengChanZhe(zy);
                xiaoFeiZhe xf = new xiaoFeiZhe(zy);
               
                Thread t1 = new Thread(sh);
                Thread t2 = new Thread(sh);
                Thread t3 = new Thread(xf);
                Thread t4 = new Thread(xf);
               
                t1.start();
                t2.start();
                t3.start();
                t4.start();
        }
}

本来是自己写的,眼看改的都和毕老师一样了,还是不知道哪里出问题,,,,,输出都会卡住,,,像是死锁,,,,想了两个多小时,实在不知道怎么搞,求指点.....或许可能就是很小的问题,但是就是解决不了..  

1. 
   
2. 
   
3. 
   
4. 
   
5. import java.util.concurrent.locks.*;
   
6. 
   
7. 
   
8. //新特性生产者消费者
   
9. 
   
10. 
    
11. class ziYuanb
    
12. {
    
13.         private String name;
    
14.         private int jiShu = 0;
    
15.         private boolean bl = false;
    
16.         private Lock lock = new ReentrantLock();
    
17. 
    
18.         
    
19.         private Condition sheng = lock.newCondition();
    
20.         private Condition xiao = lock.newCondition();
    
21.         
    
22.         
    
23.         public  void shengc(String name)throws InterruptedException
    
24.         {
    
25.                 lock.lock();
    
26.                
    
27.                
    
28.                 try
    
29.                 {
    
30.                         while(bl)
    
31.                                 sheng.await();  //1   2
    
32.                         
    
33.                         this.name = name+".."+jiShu++;
    
34.         
    
35.                         System.out.println(Thread.currentThread().getName()+",,,,,,,生产者"+this.name+jiShu);
    
36.                         
    
37.                         bl = true;
    
38.                         xiao.signalAll();
    
39.                 }
    
40.                 finally
    
41.                 {
    
42.                         lock.unlock();
    
43.                 }
    
44.         }
    
45.         public void xiaoc() throws InterruptedException
    
46.         {
    
47.                 lock.lock();
    
48.                 try
    
49.                 {
    
50.                         while(!bl)
    
51.                                 xiao.await(); //3
    
52.                         System.out.println(Thread.currentThread().getName()+".....消费者"+this.name+jiShu);
    
53.                         bl = false;
    
54.                        sheng.signalAll();
    
55.                 }
    
56.                 finally
    
57.                 {
    
58.                         lock.unlock();
    
59.                 }
    
60.         }
    
61. }
    
62. 
    
63. class shengChanZhe implements Runnable
    
64. {
    
65.         private ziYuanb zy=new ziYuanb();
    
66.         shengChanZhe(ziYuanb zy)
    
67.         {
    
68.                 this.zy = zy;
    
69.         }
    
70.         public void run()
    
71.         {
    
72.                 while(true)
    
73.                 {
    
74.                         try
    
75.                         {
    
76.                                 zy.shengc("+煎饼果子");
    
77.                         } catch (InterruptedException e)
    
78.                         {
    
79.                                 
    
80.                         }
    
81.                 }
    
82.         }
    
83. }
    
84. 
    
85. class xiaoFeiZhe implements Runnable
    
86. {
    
87.         private ziYuanb zy=new ziYuanb();;
    
88.         xiaoFeiZhe(ziYuanb zy)
    
89.         {
    
90.                 this.zy = zy;
    
91.         }
    
92.         public void run()
    
93.         {
    
94.                 while(true)
    
95.                 {
    
96.                         try {
    
97.                                 zy.xiaoc();
    
98.                         } catch (InterruptedException e) {
    
99.                         
    
100.                         }
     
101.                 }
     
102.         }
     
103. }
     
104. 
     
105. 
     
106. class Demo06 {
     
107.         public static void main(String[] args) {
     
108.                 ziYuanb zy = new ziYuanb();
     
109.                
     
110.                 shengChanZhe sh = new shengChanZhe(zy);
     
111.                 xiaoFeiZhe xf = new xiaoFeiZhe(zy);
     
112.                
     
113.                 Thread t1 = new Thread(sh);
     
114.                 Thread t2 = new Thread(sh);
     
115.                 Thread t3 = new Thread(xf);
     
116.                 Thread t4 = new Thread(xf);
     
117.                
     
118.                 t1.start();
     
119.                 t2.start();
     
120.                 t3.start();
     
121.                 t4.start();
     
122.         }
     
123. }

复制代码

1. package cn.fuxi12;
   
2. 
   
3. import java.util.concurrent.locks.Condition;
   
4. import java.util.concurrent.locks.Lock;
   
5. import java.util.concurrent.locks.ReentrantLock;
   
6. 
   
7. //新特性生产者消费者
   
8. 
   
9. 
   
10. class ziYuanb
    
11. {
    
12.          private String name;
    
13.          private int jiShu = 0;
    
14.          private boolean bl = false;
    
15.          private Lock lock = new ReentrantLock();
    
16. 
    
17.         
    
18.         private Condition sheng = lock.newCondition();
    
19.          private Condition xiao = lock.newCondition();
    
20.          
    
21.         
    
22.         public  void shengc(String name)throws InterruptedException
    
23.          {
    
24.                  lock.lock();
    
25.                  
    
26.                
    
27.                 try
    
28.                  {
    
29.                          while(bl)
    
30.                                  sheng.await();  //1   2
    
31.                         
    
32.                         this.name = name+".."+jiShu++;
    
33.          
    
34.                         System.out.println(Thread.currentThread().getName()+",,,,,,,生产者"+this.name+jiShu);
    
35.                         
    
36.                         bl = true;
    
37.                          xiao.signal();
    
38.                  }
    
39.                  finally
    
40.                  {
    
41.                          lock.unlock();
    
42.                  }
    
43.          }
    
44.          public void xiaoc() throws InterruptedException
    
45.          {
    
46.                  lock.lock();
    
47.                  try
    
48.                  {
    
49.                          while(!bl)
    
50.                                  xiao.await(); //3
    
51.                         System.out.println(Thread.currentThread().getName()+".....消费者"+this.name+jiShu);
    
52.                          bl = false;
    
53.                          sheng.signal();
    
54.                  }
    
55.                  finally
    
56.                  {
    
57.                          lock.unlock();
    
58.                  }
    
59.          }
    
60. }
    
61. 
    
62. class shengChanZhe implements Runnable
    
63. {
    
64.          private ziYuanb zy;
    
65.          shengChanZhe(ziYuanb zy)
    
66.          {
    
67.                  this.zy = zy;
    
68.          }
    
69.          public void run()
    
70.          {
    
71.                  while(true)
    
72.                  {
    
73.                          try
    
74.                         {
    
75.                                  zy.shengc("+煎饼果子");
    
76.                          } catch (InterruptedException e)
    
77.                         {
    
78.                                  
    
79.                         }
    
80.                  }
    
81.          }
    
82. }
    
83. 
    
84. class xiaoFeiZhe implements Runnable
    
85. {
    
86.          private ziYuanb zy;
    
87.          xiaoFeiZhe(ziYuanb zy)
    
88.          {
    
89.                  this.zy = zy;
    
90.          }
    
91.          public void run()
    
92.         {
    
93.                  while(true)
    
94.                  {
    
95.                          try {
    
96.                                  zy.xiaoc();
    
97.                          } catch (InterruptedException e) {
    
98.                         
    
99.                         }
    
100.                  }
     
101.          }
     
102. }
     
103. 
     
104. 
     
105. public class Demo06 {
     
106.          public static void main(String[] args) {
     
107.                  ziYuanb zy = new ziYuanb();
     
108.                  
     
109.                 shengChanZhe sh = new shengChanZhe(zy);
     
110.                  xiaoFeiZhe xf = new xiaoFeiZhe(zy);
     
111.                  
     
112.                 Thread t1 = new Thread(sh);
     
113.                  Thread t2 = new Thread(sh);
     
114.                  Thread t3 = new Thread(xf);
     
115.                  Thread t4 = new Thread(xf);
     
116.                  
     
117.                 t1.start();
     
118.                  t2.start();
     
119.                  t3.start();
     
120.                  t4.start();
     
121.          }
     
122. }
     

复制代码

    try {
                                    while(bl)
                                           sheng.await();  //1   2
            this.name = name+".."+jiShu++;
            System.out.println(Thread.currentThread().getName()+",,,,,,,生产者"+this.name+jiShu);
            bl = true;
            xiao.signal();//sheng.signal();注意，之前是消费者等待，然后，标记设为 false ，就应该让生产者唤醒啦
        }
    建立多个 Condition 对象，使用时要注意分析：谁等待着，需要谁唤醒了