生产者消费者问题

生产者和消费者问题是java多线程中的等待唤醒机制的经典案例。
下面通过几个例子，循序渐进得了解这个问题。

1.单生产者和单消费者

1 class Res
2 {
3     private String name;
4     private int count=0;
5     private boolean flag=false;//用来标志资源是否为空
6     public Res(String name)
7     {
8         this.name=name;
9     }
10     //为其他类提供实现资源存放的方法
11     public synchronized void  set()
12     {
13         //如果资源内容是满的
14         //此时执行的线程，即生产者线程等待
15         if(flag)
16         {    try
17             {
18                 this.wait();
19             }
20             catch (Exception e)
21             {
22                 System.out.println("出错了");
23             }
24         }
25         //否则，资源内容为空
26         //新生产一个产品
27         count++;
28         System.out.println("生产者生产了"+name+count);
29         //修改标志
30         flag=true;
31         //唤醒在此对象监视器上等待的某个线程，即消费者线程
32         //第一次执行时，没有等待线程，为空唤醒
33         this.notify();
34     }
35
36     //为其他类提供资源提取的方法
37     public synchronized void  out()
38     {
39         //如果资源内容是空的
40         //此时执行的线程，即消费者线程等待
41         if(!flag)
42         {    try
43             {
44                 this.wait();
45             }
46             catch (Exception e)
47             {
48                 System.out.println("出错了");
49             }
50         }
51         //否则，资源内容存在
52         //则消费该产品
53         System.out.println("消费者消费了~~~~~~~~~"+name+count);
54         //修改标志
55         flag=false;
56         //唤醒在此对象监视器上等待的某个线程，即生产者线程
57         this.notify();
58     }
59 }
60 class Producer1 implements Runnable
61 {
62     Res r;
63     public Producer1(Res r)
64     {
65         this.r=r;
66     }
67
68 //实现run方法
69     public void run()
70     {
71
72         while(true)
73         {
74             r.set();
75         }
76     }
77
78 }
79 class Customer1 implements Runnable
80 {
81     Res r;
82     public Customer1(Res r)
83     {
84         this.r=r;
85     }
86
87     //实现run方法
88     public void run()
89     {
90         while(true)
91         {
92             r.out();
93         }
94     }
95 }
96 public  class  ProducerAndCustomerDemo1
97 {
98     public static void main(String[] args)
99     {
100         //建立资源对象
101         Res r=new Res("冰淇淋");
102         //创建生产者
103         Producer1 pro=new Producer1(r);
104         //创建消费者
105         Customer1 con=new Customer1(r);
106
107         //建立线程
108         Thread t1=new Thread(pro);
109         Thread t2=new Thread(con);
110         //开启线程
111         t1.start();
112         t2.start();
113
114     }
115 }

运行如下：



 

2.多生产者和多消费者问题

多生产者和多消费者的情况，如果仍然按照上述写法来写，会发生两种错误：

第一种，输出表现是某个产品被消费了多次或者某个产品没有被消费。

产生原因是，线程被唤醒后接着往下执行，没有再判断flag标记。

解决办法：把if语句，改为while循环。

这时，又会产生第二种错误，死锁。

输出表现：程序自行停止。

产生原因：线程进行唤醒动作时，唤醒了本类线程（例如，消费者线程唤醒了消费者线程），

没能达到唤醒对方的效果（例如，消费者线程应该唤醒生产者线程），而本类线程在进行标志位判断后

，也进入了等待状态，最终致使所有线程都在等待状态，程序停止。

解决办法：把notify语句改为notifyAll，确保线程每次执行唤醒动作时，都能达到唤醒对方的效果。

1 class Res
2 {
3     private String name;
4     private int count=0;
5     private boolean flag=false;
6     public Res(String name)
7     {
8         this.name=name;
9     }
10
11     public synchronized void  set()
12     {
13         //while循环判断标志位
14         while(flag)
15         {    try
16             {
17                 this.wait();
18             }
19             catch (Exception e)
20             {
21                 System.out.println("出错了");
22             }
23         }
24
25         count++;
26         System.out.println("生产者"+Thread.currentThread().getName()+"生产了"+name+count);
27         flag=true;
28         //唤醒在此对象监视器上等待的所有线程
29         this.notifyAll();
30     }
31
32     public synchronized void  out()
33     {
34         //while循环判断标志位
35         while(!flag)
36         {    try
37             {
38                 this.wait();
39             }
40             catch (Exception e)
41             {
42                 System.out.println("出错了");
43             }
44         }
45         System.out.println("消费者"+Thread.currentThread().getName()+"消费了~~~~~~~~~"+name+count);
46         flag=false;
47         //唤醒在此对象监视器上等待的所有线程
48         this.notifyAll();
49     }
50 }
51 class Producer1 implements Runnable
52 {
53     Res r;
54     public Producer1(Res r)
55     {
56         this.r=r;
57     }
58
59     public void run()
60     {
61
62         while(true)
63         {
64             r.set();
65         }
66     }
67
68 }
69 class Customer1 implements Runnable
70 {
71     Res r;
72     public Customer1(Res r)
73     {
74         this.r=r;
75     }
76
77     public void run()
78     {
79         while(true)
80         {
81             r.out();
82         }
83     }
84 }
85 public  class  ProducerAndCustomerDemo2
86 {
87     public static void main(String[] args)
88     {
89         //建立资源对象
90         Res r=new Res("冰淇淋");
91         //创建生产者
92         Producer1 pro=new Producer1(r);
93         //创建消费者
94         Customer1 con=new Customer1(r);
95
96         //建立线程
97         Thread t0=new Thread(pro);
98         Thread t1=new Thread(pro);
99         Thread t2=new Thread(con);
100         Thread t3=new Thread(con);
101         //开启线程
102         t0.start();
103         t1.start();
104         t2.start();
105         t3.start();
106
107     }
108 }

运行如下：



 

3.多生产者和多消费者问题（JDK1.5的新特性）

两个代替：

JDK1.5的新特性
用Lock接口的实现类，封装锁对象，显式完成申请锁和释放锁的动作，以此代替synchronized同步方法的使用；
Lock实现类的锁对象，最大的好处是，一个锁可以有多个监视器（即Condition对象，而同步代码块的锁只能有一个监视器），
这样就可以分别为生产者和消费者建立不同的监视器，实现只唤醒对方的操作，用指定监视器的singal方法代替了notifyAll方法。

1 import java.util.concurrent.locks.*;
2 class Rec
3 {
4     private String name;
5     private int count=0;
6     private boolean flag=false;
7     //建立锁对象
8     Lock lock=new ReentrantLock();
9     //得到该锁对象的两个监视器
10     //分别用于生产者和消费者
11     Condition producer_con=lock.newCondition();
12     Condition customer_con=lock.newCondition();
13
14     public Rec(String name)
15     {
16         this.name=name;
17     }
18     public void set()
19     {
20         //获取锁
21         lock.lock();
22         try
23         {
24             while(flag)
25             try
26             {
27                 //调用Condition对象的await方法
28                 producer_con.await();
29             }
30             catch (Exception e)
31             {
32                 System.out.println("有错误");
33             }
34             count++;
35             System.out.println(Thread.currentThread().getName()+"生产者~~JDK1.5~~，生产出了"+name+count);
36
37             flag=true;
38             //用消费者线程的监视器唤醒消费者
39             customer_con.signal();
40         }
41         /*加入try finally结构
42         原因：如果try代码块中出现异常，释放锁的动作就不会被执行
43         因此把释放锁动作放在finally中，确保其执行。
44
45         */
46         finally
47         {
48             //释放锁
49             lock.unlock();
50         }
51     }
52
53     public void out()
54     {
55         //获取锁
56         lock.lock();
57         try
58         {
59             while(!flag)
60             try
61             {
62                 customer_con.await();
63             }
64             catch (Exception e)
65             {
66                     System.out.println("有错误");
67
68             }
69
70         System.out.println(Thread.currentThread().getName()+"消费者~~~~~~~~~JDK1.5~~~~~~~~~~吃掉了"+name+count);
71         flag=false;
72         //用生产者线程的监视器唤醒生产者
73         producer_con.signal();
74         }
75         finally
76         {
77             //释放锁
78             lock.unlock();
79         }
80
81
82     }
83
84
85 }
86 class Producer implements Runnable
87 {
88     Rec r;
89     public Producer(Rec r)
90     {
91         this.r=r;
92     }
93
94     public void run()
95     {
96         while(true)
97         {
98             r.set();
99         }
100     }
101 }
102 class Customer implements Runnable
103 {
104     Rec r;
105     public Customer(Rec r)
106     {
107         this.r=r;
108     }
109
110     public void run()
111     {
112         while(true)
113         {
114             r.out();
115         }
116     }
117 }
118 public class  ProAndConLockSolution
119 {
120     public static void main(String[] args)
121     {
122         Rec r=new Rec("北京烤鸭");
123         Producer pro1=new Producer(r);
124         Producer pro2=new Producer(r);
125         Customer con1=new Customer(r);
126         Customer con2=new Customer(r);
127
128         Thread t0=new Thread(pro1);
129         Thread t1=new Thread(pro2);
130         Thread t2=new Thread(con1);
131         Thread t3=new Thread(con2);
132
133         t0.start();
134         t1.start();
135         t2.start();
136         t3.start();
137
138
139     }
140 }