C# Producer Consumer （生产者消费者模式）demo

第一套代码将producer Consumer的逻辑写到from类里了，方便在demo的显示界面动态显示模拟生产和消费的过程。
     第二套代码将producer Consumer的逻辑单独写到一个类中，使用委托的方法在from中回显生产消费的过程。
     Demo中均以3个线程作为消费者，1个线程作为生产者为例。 
     由于是C#新手，有不对的地方望不吝赐教。

先贴下窗口截图，动态生产消费进度显示

第一套代码：

1. using System;
2. using System.Collections.Generic;
3. using System.ComponentModel;
4. using System.Data;
5. using System.Drawing;
6. using System.Linq;
7. using System.Text;
8. using System.Windows.Forms;
9. using System.Threading;
10. namespace ProducerConsumerDemo
11. {
12. public partial class Form1 : Form
13. {
14. public Form1()
15. {
16. InitializeComponent();
17. }
18. private void button1_Click(object sender, EventArgs e)
19. {
20. StopFlag = false;
21. StartDemo();
22. }
23. private void button2_Click(object sender, EventArgs e)
24. {
25. StopFlag = true;
26. }
27. public class TaskInfo
28. {
29. public int Index;
30. public TaskInfo()
31. {
32. }
33. public TaskInfo(int index)
34. {
35. this.Index = index;
36. }
37. }
38. private static bool StopFlag = false;
39. private int ProducerNumber = 1;
40. private int ConsumerNumber = 3;
41. // 共用任务队列
42. private Queue<TaskInfo> TaskQueue = new Queue<TaskInfo>();
43. private Semaphore TaskSemaphore = new Semaphore(0, 256);
44. private object myLock = new object();
45. private void StartDemo()
46. {
47. StartProducer(ProducerNumber);
48. Thread.Sleep(2000);
49. StartConsumer(ConsumerNumber);
50. }
51. private void StartProducer(int num)
52. {
53. for (int i = 0; i < num; i++)
54. {
55. Thread t = new Thread(new ThreadStart(Producer));
56. t.Name = "Producer_" + (i + 1);
57. t.Start();
58. }
59. }
60. private void StartConsumer(int num)
61. {
62. for (int i = 0; i < num; i++)
63. {
64. Thread t = new Thread(new ParameterizedThreadStart(this.Consumer));
65. t.Name = "Consumer_" + (i + 1);
66. t.IsBackground = true;
67. t.Start(i + 1);
68. }
69. }
70. // 线程间控件调用，需要使用委托
71. public delegate void ProducerTextDelegate(string AddStr);
72. public delegate void ComsumerTextDelegate(int Index, string AddStr);
73. // 生产者
74. private void Producer()
75. {
76. int i = 0;
77. while (!StopFlag)
78. {
79. TaskInfo Task = new TaskInfo(++i);
80. lock (myLock)   // 任务队列为临界资源，需要锁
81. {
82. TaskQueue.Enqueue(Task);
83. }
84. TaskSemaphore.Release(1);   // 每添加一个任务，信号量加1
85. string AddText = String.Format("Task {0} was Produced.\r\n", Task.Index);
86. ChangeProducerText(AddText);    // 修改textBox输出
87. Thread.Sleep(1000);
88. }
89. }
90. // 消费者
91. private void Consumer(object data)
92. {
93. int Index = (int)data;
94. TaskInfo GetTask = null;
95. while (true)
96. {
97. TaskSemaphore.WaitOne();
98. lock (myLock)
99. {
100. GetTask = TaskQueue.Dequeue();
101. }
102. string AddStr = String.Format("Consumer {0} take Task {1}\r\n", Index, GetTask.Index);
103. ChangeConsumerText(Index, AddStr);
104. Random r = new Random();
105. Thread.Sleep(r.Next(5) * 1000);     // 休眠随机事件，模拟实际任务的每个任务的不同时常
106. // 此处应为任务处理
107. }
108. }
109. private void ChangeProducerText(string AddStr)
110. {
111. if (textBox1.InvokeRequired)
112. {
113. ProducerTextDelegate pd = new ProducerTextDelegate(ChangeProducerText);
114. textBox1.Invoke(pd, new object[] { AddStr });
115. }
116. else
117. {
118. textBox1.AppendText(AddStr);
119. }
120. }
121. private void ChangeConsumerText(int Index, string AddStr)
122. {
123. TextBox currentTextBox = null;
124. switch (Index)
125. {
126. case 1:
127. currentTextBox = this.textBox2;
128. break;
129. case 2:
130. currentTextBox = this.textBox3;
131. break;
132. case 3:
133. currentTextBox = this.textBox4;
134. break;
135. default:
136. break;
137. }
138. if (currentTextBox.InvokeRequired)
139. {
140. ComsumerTextDelegate cd = new ComsumerTextDelegate(ChangeConsumerText);
141. currentTextBox.Invoke(cd, new object[] { Index, AddStr });
142. }
143. else
144. {
145. currentTextBox.AppendText(AddStr);
146. }
147. }
148. }
149. }

第二套代码：

1. // Form1.cs
2. using System;
3. using System.Collections.Generic;
4. using System.ComponentModel;
5. using System.Data;
6. using System.Drawing;
7. using System.Linq;
8. using System.Text;
9. using System.Windows.Forms;
10. using System.Threading;
11. namespace ProducerConsumerDemo
12. {
13. // 定义修改输出的委托
14. public delegate void ShowTextDelegate(int Index, string Addstr);
15. public partial class Form1 : Form
16. {
17. Work work = null;
18. public Form1()
19. {
20. InitializeComponent();
21. work = new Work();
22. work.ShowTextEvent += new ShowTextDelegate(ChangeTextValue);
23. }
24. private void button1_Click(object sender, EventArgs e)
25. {
26. work.Start();
27. }
28. private void button2_Click(object sender, EventArgs e)
29. {
30. work.Stop();
31. }
32. // new Work 中再起的子线程调用的ShowTextDelegate委托事件，所以需要委托才能调用textBox控件
33. public delegate void ChangeTextDelegate(int Index, string AddStr);
34. private void ChangeTextValue(int Index, string AddStr)
35. {
36. TextBox ChangeTextBox = null;
37. switch (Index)
38. {
39. case 1:
40. ChangeTextBox = this.textBox1;
41. break;
42. case 2:
43. ChangeTextBox = this.textBox2;
44. break;
45. case 3:
46. ChangeTextBox = this.textBox3;
47. break;
48. case 4:
49. ChangeTextBox = this.textBox4;
50. break;
51. default:
52. break;
53. }
54. if (ChangeTextBox.InvokeRequired)
55. {
56. ChangeTextDelegate pd = new ChangeTextDelegate(ChangeTextValue);
57. ChangeTextBox.Invoke(pd, new object[] { Index, AddStr });
58. }
59. else
60. {
61. ChangeTextBox.AppendText(AddStr);
62. }
63. }
64. }
65. }
66. // Work.cs
67. using System;
68. using System.Collections.Generic;
69. using System.Linq;
70. using System.Text;
71. using System.Threading;
72. namespace ProducerConsumerDemo
73. {
74. public class Work
75. {
76. public Work()
77. {
78. StopFlag = false;
79. }
80. public void Start()
81. {
82. StopFlag = false;
83. StartDemo();
84. }
85. public void Stop()
86. {
87. StopFlag = true;
88. }
89. public class TaskInfo
90. {
91. public int Index;
92. public TaskInfo()
93. {
94. }
95. public TaskInfo(int index)
96. {
97. this.Index = index;
98. }
99. }
100. private static bool StopFlag = false;
101. private int ProducerNumber = 1;
102. private int ConsumerNumber = 3;
103. private Queue<TaskInfo> TaskQueue = new Queue<TaskInfo>();
104. private Semaphore TaskSemaphore = new Semaphore(0, 256);
105. private object myLock = new object();
106. public event ShowTextDelegate ShowTextEvent;
107. private void StartDemo()
108. {
109. StartProducer(ProducerNumber);
110. Thread.Sleep(2000);
111. StartConsumer(ConsumerNumber);
112. }
113. private void StartProducer(int num)
114. {
115. for (int i = 0; i < num; i++)
116. {
117. Thread t = new Thread(new ThreadStart(Producer));
118. t.Name = "Producer_" + (i + 1);
119. t.Start();
120. }
121. }
122. private void StartConsumer(int num)
123. {
124. for (int i = 0; i < num; i++)
125. {
126. Thread t = new Thread(new ParameterizedThreadStart(this.Consumer));
127. t.Name = "Consumer_" + (i + 1);
128. t.IsBackground = true;
129. t.Start(i + 1);
130. }
131. }
132. private void Producer()
133. {
134. int i = 0;
135. while (!StopFlag)
136. {
137. TaskInfo Task = new TaskInfo(++i);
138. lock (myLock)
139. {
140. TaskQueue.Enqueue(Task);
141. }
142. TaskSemaphore.Release(1);
143. string AddText = String.Format("Task {0} was Produced.\r\n", Task.Index);
144. ShowTextEvent.Invoke(1, AddText);
145. Thread.Sleep(1000);
146. }
147. }
148. private void Consumer(object data)
149. {
150. int Index = (int)data;
151. TaskInfo GetTask = null;
152. while (true)
153. {
154. TaskSemaphore.WaitOne();
155. lock (myLock)
156. {
157. GetTask = TaskQueue.Dequeue();
158. }
159. string AddStr = String.Format("Consumer {0} take Task {1}\r\n", Index, GetTask.Index);
160. ShowTextEvent.Invoke(Index + 1, AddStr);
161. Random r = new Random();
162. Thread.Sleep(r.Next(5) * 1000);
163. }
164. }
165. }
166. }