.net实现--多线程之生产者/消费者问题

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
4. using System.Runtime.CompilerServices;
6. namespace  Concurrent
8. {
9.     public class ProducerAndConsumer
10.     {
11.         BreadContainer container;
12.         Producer pA;
13.         Consumer cA;
14.         Producer pB;
15.         Consumer cB;
17.         System.Threading.Thread thPA;
18.         System.Threading.Thread thCA;
20.         System.Threading.Thread thPB;
21.         System.Threading.Thread thCB;
23.         public void startDemo()
24.         {
25.             container = BreadContainer.Instance;
26.             pA = new Producer("PA", container, 2);
27.             cA = new Consumer("CA", container, 5);
29.             pB = new Producer("PB", container, 3);
30.             cB = new Consumer("CB", container, 10);
32.             thPA =
33.                 new System.Threading.Thread(new System.Threading.ThreadStart(pA.Produce));
35.             thCA =
36.                 new System.Threading.Thread(new System.Threading.ThreadStart(cA.Consume));
38.             thPB =
39.                 new System.Threading.Thread(new System.Threading.ThreadStart(pB.Produce));
41.             thCB =
42.                 new System.Threading.Thread(new System.Threading.ThreadStart(cB.Consume));
44.             thPA.Start();
45.             thCA.Start();
47.             thPB.Start();
48.             thCB.Start();
49.         }
51.         public string StopDemo()
52.         {
53.             thPA.Abort();
54.             thCA.Abort();
56.             thPB.Abort();
57.             thCB.Abort();
58.             return cA.ConsumedBreads() + "/n" + cB.ConsumedBreads();
61.         }
62.     }
64.     /// <summary>
65.     /// 面包实体类
66.     /// </summary>
67.     public class Bread
68.     {
69.         /// <summary>
70.         /// 面包生产的厂家
71.         /// </summary>
72.         private Producer _producer;
73.         /// <summary>
74.         /// 面包的标识或批次
75.         /// </summary>
76.         private int _id;
78.         public Producer Producer
79.         {
80.             get { return _producer; }
81.         }
83.         public int ID
84.         {
85.             get { return _id; }
86.         }
88.         public Bread(int id, Producer producer)
89.         {
90.             _producer = producer;
91.             _id = id;
92.         }
93.     }
95.     /// <summary>
96.     /// 装面包的容器类
97.     /// </summary>
98.     public class BreadContainer
99.     {
100.         /// <summary>
101.         /// 面包容器
102.         /// </summary>
103.         private Bread[] _container;
105.         private int _index;
107.         /// <summary>
108.         /// 容量
109.         /// </summary>
110.         private int _capability = 10;
112.         protected BreadContainer()
113.         {
114.             _container = new Bread[_capability];
115.             _index = -1;
117.             
118.         }
120.         /// <summary>
121.         /// note:如果不加MethodImpl,则调用线程的Abort方法时报异常
122.         /// </summary>
123.         /// <param name="bread"></param>
124.         [MethodImpl(MethodImplOptions.Synchronized)]
125.         public void InBread(Bread bread)
126.         {
127.             //lock (_container.SyncRoot)
128.             //{
129.                 if (_index == _capability)
130.                 {
131.                     System.Threading.Monitor.Wait(this);
132.                 }
134.                 _container[++_index] = bread;
135.                 System.Threading.Monitor.Pulse(this);
136.             //}
137.         }
139.         [MethodImpl(MethodImplOptions.Synchronized)]
140.         public Bread OutBread()
141.         {
142.             //lock (_container.SyncRoot)
143.             //{
144.                 if (_index < 0)
145.                 {
146.                     System.Threading.Monitor.Wait(this);
147.                 }
149.                 Bread temp = _container[_index--];
150.                 System.Threading.Monitor.Pulse(this);
151.                 return temp;
152.             //}
153.         }
155.         /// <summary>
156.         /// 容器类的唯一实例
157.         /// </summary>
158.         public static BreadContainer Instance
159.         {
160.             get
161.             {
162.                 return Nested.instance;
163.             }
164.         }
166.         class Nested
167.         {
168.             static Nested()
169.             {
170.             }
172.             internal static readonly BreadContainer instance = new BreadContainer();
173.         }
174.     }
176.     /// <summary>
177.     /// 生产厂商
178.     /// </summary>
179.     public class Producer
180.     {
181.         private string _name;
182.         private BreadContainer _breadContainer;
184.         /// <summary>
185.         /// 生产速度
186.         /// </summary>
187.         private int _speed;
188.         /// <summary>
189.         /// 生产面包的总数量
190.         /// </summary>
191.         private int _breadsCount;
193.         public string Name
194.         {
195.             get { return _name; }
196.         }
197.         public Producer(string strName, BreadContainer breadContainer, int speed)
198.         {
199.             _name = strName;
200.             _breadContainer = breadContainer;
201.             _speed = speed;
202.         }
204.         /// <summary>
205.         /// 开始生产
206.         /// </summary>
207.         public void Produce()
208.         {
209.             while (true)
210.             {
211.                 _breadContainer.InBread(new Bread(++_breadsCount, this));
213.                 System.Threading.Thread.Sleep(_speed * 1000);
214.             }
215.         }      
216.     }
218.     /// <summary>
219.     /// 消费者类
220.     /// </summary>
221.     public class Consumer
222.     {
223.         private string _name;
224.         private List<Bread> _consumptionMemo;
225.         private BreadContainer _breadContainer;
227.         /// <summary>
228.         /// 消费速度
229.         /// </summary>
230.         private int _speed;
232.         /// <summary>
233.         /// 消费者姓名
234.         /// </summary>
235.         public string Name
236.         {
237.             get { return _name; }
238.         }
240.         public Consumer(string strName, BreadContainer breadContainer,int speed)
241.         {
242.             _name = strName;
243.             _consumptionMemo = new List<Bread>();
244.             _breadContainer = breadContainer;
245.             _speed = speed;
246.          
247.         }
249.         public string ConsumedBreads()
250.         {
251.             string str = Name+"消费的清单如下:/n";
252.             foreach (Bread temp in _consumptionMemo)
253.             {
254.                 str += "厂商:"+temp.Producer.Name + ":面包id:" + temp.ID+"/n";
255.             }
256.             return str;
257.         }
259.         public void Consume()
260.         {
261.             while (true)
262.             {
263.                 _consumptionMemo.Add(_breadContainer.OutBread());
265.                 System.Threading.Thread.Sleep(_speed * 1000);
266.             }
267.         }
268.     }
269. }
271. 其它文章:http://blog.csdn.net/program_think/archive/2009/03/25/4022087.aspx