一个C#多线程的工作队列

自己写了一个多线程的工作队列，能够实现对队列中对象的自动处理。多线程添加元素到队列中，队列根据绑定

的事件进行自动处理，可以设置WorkSequential属性来实现对队列处理的单线程（严格顺序处理）或者多线程处理（循序出队，但是

多线程处理，不保证对队列元素的处理顺利）的选择。

[csharp]  view plain copy

1. /***********多线程的工作队列*************** 
2.  * 此工作队列保证线程安全性 
3.  *  
4.  *  
5.  *  
6.  *  
7.  * *******/  
8. namespace WorkQueue  
9. {  
10.     using System.Collections.Generic;  
11.     using System;  
12.     using System.Threading;  
13.   
14.   
15.     public delegate void UserWorkEventHandler<T>(object sender, WorkQueue<T>.EnqueueEventArgs e);  
16.     public class WorkQueue<T>  
17.     {  
18.         private bool IsWorking; //表明处理线程是否正在工作  
19.         private object lockIsWorking = new object();//对IsWorking的同步对象  
20.   
21.   
22.   
23.   
24.         private Queue<T> queue; //实际的队列  
25.         private object lockObj = new object(); //队列同步对象  
26.   
27.   
28.          
29.   
30.   
31.   
32.   
33.         /// <summary>  
34.         /// 绑定用户需要对队列中的item对象  
35.         /// 施加的操作的事件  
36.         /// </summary>  
37.         public event UserWorkEventHandler<T> UserWork;  
38.   
39.   
40.         public WorkQueue(int n)  
41.         {  
42.             queue = new Queue<T>(n);  
43.         }  
44.   
45.   
46.         public WorkQueue()  
47.         {  
48.             queue = new Queue<T>();  
49.         }  
50.   
51.   
52.         /// <summary>  
53.         /// 谨慎使用此函数，  
54.         /// 只保证此瞬间，队列值为空  
55.         /// </summary>  
56.         /// <returns></returns>  
57.         public bool IsEmpty()  
58.         {  
59.             lock (lockObj)  
60.             {  
61.                 return queue.Count == 0;  
62.             }  
63.         }  
64.   
65.   
66.         private bool isOneThread;  
67.   
68.   
69.         /// <summary>  
70.         /// 队列处理是否需要单线程顺序执行  
71.         /// ture表示单线程处理队列的T对象  
72.         /// 默认为false，表明按照顺序出队，但是多线程处理item  
73.         /// *****注意不要频繁改变此项****  
74.         /// </summary>  
75.         public bool WorkSequential  
76.         {  
77.             get  
78.             {  
79.                 return isOneThread;  
80.             }  
81.             set  
82.             {  
83.                 isOneThread = value;  
84.             }  
85.   
86.   
87.         }  
88.   
89.   
90.   
91.   
92.         /// <summary>  
93.         /// 向工作队列添加对象，  
94.         /// 对象添加以后，如果已经绑定工作的事件  
95.         /// 会触发事件处理程序，对item对象进行处理  
96.         /// </summary>  
97.         /// <param name="item">添加到队列的对象</param>  
98.         public void EnqueueItem(T item)  
99.         {  
100.             lock (lockObj)  
101.             {  
102.                 queue.Enqueue(item);  
103.             }  
104.   
105.   
106.             lock (lockIsWorking)  
107.             {  
108.                 if (!IsWorking)  
109.                 {  
110.                     IsWorking = true;  
111.                     ThreadPool.QueueUserWorkItem(doUserWork);  
112.                 }  
113.             }  
114.   
115.   
116.   
117.   
118.         }  
119.   
120.   
121.         /// <summary>  
122.         /// 处理队列中对象的函数  
123.         /// </summary>  
124.         /// <param name="o"></param>  
125.         private void doUserWork(object o)  
126.         {  
127.             try  
128.             {  
129.                 T item;  
130.   
131.   
132.                 while (true)  
133.                 {  
134.                     lock (lockObj)  
135.                     {  
136.                         if (queue.Count > 0)  
137.                         {  
138.                             item = queue.Dequeue();  
139.                         }  
140.                         else  
141.                         {  
142.                             return;  
143.                         }  
144.                     }  
145.                     if (!item.Equals(default(T)))  
146.                     {  
147.   
148.   
149.                         if (isOneThread)  
150.                         {  
151.                             if (UserWork != null)  
152.                             {  
153.                                 UserWork(this, new EnqueueEventArgs(item));  
154.                             }  
155.                         }  
156.                         else  
157.                         {  
158.                             ThreadPool.QueueUserWorkItem(obj =>  
159.                                                              {  
160.                                                                  if (UserWork != null)  
161.                                                                  {  
162.                                                                      UserWork(this, new EnqueueEventArgs(obj));  
163.                                                                  }  
164.                                                              }, item);  
165.                         }  
166.                           
167.   
168.   
169.                     }  
170.   
171.   
172.                 }  
173.             }  
174.             finally  
175.             {  
176.                 lock (lockIsWorking)  
177.                 {  
178.                     IsWorking = false;  
179.                 }  
180.   
181.   
182.             }  
183.         }  
184.   
185.   
186.         /// <summary>  
187.         /// UserWork事件的参数，包含item对象  
188.         /// </summary>  
189.         public class EnqueueEventArgs : EventArgs  
190.         {  
191.             public T Item { get; private set; }  
192.             public EnqueueEventArgs(object item)  
193.             {  
194.                 try  
195.                 {  
196.                     Item = (T)item;  
197.                 }  
198.                 catch (Exception)  
199.                 {  
200.   
201.   
202.                     throw new InvalidCastException("object to T 转换失败");  
203.                 }  
204.             }  
205.         }  
206.     }  
207. }  

[csharp]  view plain copy

1.   

[csharp]  view plain copy

1. 示例代码：  

[csharp]  view plain copy

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.Threading;  
6. using System.IO;  
7. using WorkQueue;  
8. namespace Program  
9. {  
10.     class Program  
11.     {  
12.         private static List<string> list=new List<string>(1000);  
13.         static  StreamWriter sw = new StreamWriter(new FileStream("test.dat", FileMode.Create));  
14.         static void Main(string[] args)  
15.         {  
16.             WorkQueue<int> workQueue=new WorkQueue<int>(1000);  
17.             workQueue.UserWork += new UserWorkEventHandler<int>(workQueue_UserWork);  
18.            // workQueue.WorkSequential = true;  
19.             ThreadPool.QueueUserWorkItem(o =>  
20.                                              {  
21.                                                  for (int i = 0; i < 1000; i++)  
22.                                                  {  
23.                                                      workQueue.EnqueueItem(i);  
24.   
25.   
26.                                                  }  
27.                                              });  
28.             Console.ReadLine();  
29.   
30.   
31.             list.ForEach(str=>sw.WriteLine(str));  
32.             Console.WriteLine(workQueue.IsEmpty());  
33.             sw.Close();  
34.         }  
35.   
36.   
37.         static void workQueue_UserWork(object sender, WorkQueue<int>.EnqueueEventArgs e)  
38.         {  
39.              
40.             StringBuilder sb=new StringBuilder();  
41.             sb.Append(e.Item).Append("\t\t").Append(DateTime.Now.ToString("u")+"\t\t").Append(Thread.CurrentThread.ManagedThreadId);  
42.             list.Add(sb.ToString());  
43.             Thread.Sleep(15);  
44.         }  
45.     }  
46. }