C#如何对多线程、多任务管理（demo）

这篇文章主要通过一个小demo介绍了C#如何对多线程、多任务管理,需要的朋友可以参考下

下面一段内容有项目需求有项目分析，通过一个小demo给大家展示下C#如何对多线程、多任务管理的。

项目需求：假设多个任务需要执行，每个任务不是一时半会能完成(需要能看到中间执行状况);

多个任务 根据条件不同 可能需要不同的处理

项目分析： 多线程并发执行多任务;

对任务进行管理，追踪中间执行状态;

运用策略模式抽象执行类;

1. public enum TaskStatus 
2. { 
3. wait = 0, 
4. working = 1, 
5. stop = 2, 
6. suspend = 3, 
7. complete = 4, 
8. fail = 5, 
9. other = 99 
10. } 
11.  
12. public class Task 
13. { 
14. public TaskDelegate<ParaStatus> taskStatus; 
15. public TaskDelegate<ParaInfo> taskInfo; 
16. public TaskDelegate<ParaProcess> taskProcess; 
17.  
18. private TaskStatus _status = TaskStatus.wait; 
19. private IExecuter _Executer { get; set; } 
20. private Guid _taskId; 
21. private Thread thread; 
22. private string _name; 
23.  
24. public Task(Guid id, IExecuter Executer) 
25. { 
26. _taskId = id; 
27. _Executer = Executer; 
28. _Executer.TaskId = id; 
29. _Executer.Task = this; 
30. } 
31.  
32. public void Wait() 
33. { 
34. ChangeStatus(TaskStatus.wait); 
35. } 
36.  
37. public string Name 
38. { 
39. get 
40. { 
41. return _name; 
42. } 
43. set 
44. { 
45. _name = value; 
46. } 
47. } 
48.  
49. public Guid TaskId 
50. { 
51. get 
52. { 
53. return _taskId; 
54. } 
55. } 
56.  
57. public TaskStatus Status 
58. { 
59. get 
60. { 
61. return _status; 
62. } 
63. set 
64. { 
65. _status = value; 
66. } 
67. }  
68.  
69. public void Start() 
70. { 
71. if (thread == null) 
72. { 
73. thread = new Thread(_Executer.Do); 
74. } 
75. else if (thread.ThreadState == ThreadState.Stopped) 
76. { 
77. thread = new Thread(_Executer.Do); 
78. } 
79. thread.Start(); 
80. ChangeStatus(TaskStatus.working); 
81. } 
82. public void ChangeStatus(TaskStatus s) 
83. { 
84. Status = s; 
85. ParaStatus ps = new ParaStatus(TaskId); 
86. ps.Status = Status; 
87. if (taskStatus != null) taskStatus(ps); 
88. } 
89. public void Stop() 
90. { 
91. if (thread != null) 
92. { 
93. if (thread.IsAlive) 
94. { 
95. try 
96. { 
97. thread.Abort(); 
98. } 
99. catch { } 
100. } 
101. } 
102. ChangeStatus(TaskStatus.stop); 
103. } 
104. public void Suspend() 
105. { 
106. try 
107. { 
108. thread.Suspend(); 
109. } 
110. catch { } 
111. ChangeStatus(TaskStatus.suspend); 
112. } 
113. public void Resume() 
114. { 
115. if (thread.IsAlive) 
116. { 
117. thread.Resume(); 
118. } 
119. ChangeStatus(TaskStatus.working); 
120. } 
121. } 
122.  
123. public interface IExecuter 
124. { 
125. Guid TaskId { get; set; } 
126.  
127. Task Task { get; set; } 
128. void Do(); 
129. } 
130.  
131.  
132.  
133. public class Executer : IExecuter 
134. { 
135. public void Execute() 
136. { 
137.  
138. } 
139. #region IExecute 
140. public Guid TaskId { get; set; } 
141.  
142. public Task Task { get; set; } 
143.  
144. public void Do() 
145. { 
146. for (int i = 1; i <= 100; i++) 
147. { 
148. if (Task.taskProcess != null) 
149. { 
150. Thread.Sleep(1000); 
151. ParaProcess pp = new ParaProcess(TaskId); 
152. pp.Rate = (double)i / 100; 
153. Task.taskProcess(pp);  
154. } 
155. } 
156. if (Task.taskStatus != null) 
157. { 
158. Task.ChangeStatus(TaskStatus.complete); 
159. } 
160. } 
161. #endregion 
162. } 
163.  
164. public class TaskManager 
165. { 
166. public List<Task> Tasks = new List<Task>(); 
167. /// <summary> 
168. /// 添加任务 
169. /// </summary> 
170. public Task AddTask(Task task) 
171. { 
172. try 
173. { 
174. Tasks.Add(task); 
175.  
176. task.Wait(); 
177. } 
178. catch (Exception e) 
179. { 
180.  
181. } 
182. return task; 
183. } 
184. public void StartTask(Task task) 
185. { 
186. task.Start(); 
187. } 
188. /// <summary> 
189. /// 停止任务 
190. /// </summary> 
191. /// <param name="downloader"></param> 
192. public void StopTask(Task task) 
193. { 
194. task.Stop(); 
195. } 
196.  
197. public void SuspendTask(Task task) 
198. { 
199. task.Suspend(); 
200. } 
201.  
202. public void ResumeTask(Task task) 
203. { 
204. task.Resume(); 
205. } 
206.  
207. /// <summary> 
208. /// 删除任务(自动终止未停止的任务) 
209. /// </summary> 
210. /// <param name="downloader"></param> 
211. public void DeleteTask(Task task, bool deleteFile) 
212. { 
213. //先停止任务 
214. task.Stop(); 
215.  
216. while (task.Status == TaskStatus.working) 
217. { 
218. Thread.Sleep(50); 
219. } 
220.  
221. //从任务列表中删除任务 
222. if (Tasks.Contains(task)) 
223. { 
224. Tasks.Remove(task); 
225. } 
226. } 
227.  
228. } 
229.  
230.  
231. /// </summary> 
232. /// <param name="para">泛型参数</param> 
233. public delegate void TaskDelegate<T>(T para); 
234.  
235. /// <summary> 
236. ///  
237. /// </summary> 
238. public class ParaStatus 
239. { 
240. public ParaStatus(Guid task) { TaskId = task; } 
241. public Guid TaskId { get; set; } 
242. public TaskStatus Status { get; set; } 
243. }  
244.  
245. public class ParaInfo 
246. { 
247. public ParaInfo(Guid task) { TaskId = task; } 
248. public Guid TaskId { get; set; } 
249. public string Info { get; set; } 
250. } 
251.  
252. public class ParaProcess 
253. { 
254. public ParaProcess(Guid task) { TaskId = task; } 
255. public Guid TaskId { get; set; } 
256. public double Rate { get; set; }  
257. } 

以上代码内容就是C#对多线程、多任务管理的方法，希望对大家有所帮助。