C# 多线程编程 ThreadStart ParameterizedThreadStart

1. 原文地址：http://club.topsage.com/thread-657023-1-1.html
2. 在实例化Thread的实例，需要提供一个委托，在实例化这个委托时所用到的参数是线程将来启动时要运行的方法。在.net中提供了两种启动线程的方式，一种是不带参数的启动方式，另一种是带参数的启动的方式。
3. 不带参数的启动方式
4. 如果启动参数时无需其它额外的信息，可以使用ThreadStart来实例化Thread，如下面的代码：
5. 1 using System;
6. 2 using System.Collections.Generic;
7. 3 using System.Text;
8. 4 using System.Threading;
9. 5
10. 6 namespace StartThread
11. 7 {
12. 8          class Program
13. 9          {
14. 10                  int interval = 200;
15. 11                  static void Main(string[] args)
16. 12                  {
17. 13                          Program p = new Program();
18. 14                          Thread nonParameterThread = new Thread(new ThreadStart(p.NonParameterRun));
19. 15                          nonParameterThread.Start();
20. 16                  }
21. 17                  ///<summary>
22. 18 /// 不带参数的启动方法
23. 19 ///</summary>
24. 20                  public void NonParameterRun()
25. 21                  {
26. 22                          for (int i = 0; i < 10; i++)
27. 23                          {
28. 24                                  Console.WriteLine("系统当前时间毫秒值："+DateTime.Now.Millisecond.ToString());
29. 25                                  Thread.Sleep(interval);//让线程暂停
30. 26                          }
31. 27          }
32. 28 }
33. 程序的运行效果我们不用运行也会知道，那就是在循环中将系统当前时间的毫秒部分输出出来，在每次输出之后会将当前线程暂停一下，直到10次之后运行完毕，终止线程的执行。
34. 在上面的代码中我们是通过定义全局变量的方法来指定线程暂停间隔，按照这种方法，假如要运行10个线程，每个线程的暂停间隔不一样的话，就需要定义10个全局变量，虽然最终不影响系统的运行效果，但是总觉得不是太爽。
35. 有没有比较简单一点的办法呢？有！那就是使用带参数的启动方法。
36. 带参数的启动方法
37. 如果要在实例化线程时要带一些参数，就不能用ThreadStart委托作为构造函数的参数来实例化Thread了，而要 ParameterizedThreadStart委托，和ThreadStart一样的是它也是线程启动时要执行的方法，和ThreadStart不同的是，它在实例化时可以用一个带有一个Object参数的方法作为构造函数的参数，而实例化ThreadStart时所用到的方法是没有参数的。
38. 为什么是Object这样的参数呢？很简单，因为在.net中Object是所有类型的基类，用它可以表示Array(数组）、Interface（接口）、ValueType（值类型，如bool,byte,char,short,int,float,long,double等）、class(类）等.net中的类型。当然，这也意味着如果你要启动一个线程，给它传递一个int类型参数时，必须在   启动方法中进行相应的类型转换。
39. 下面就是一个例子，在启动线程时指定了线程的暂停间隔，代码如下：
40. 1 using System;
41. 2 using System.Collections.Generic;
42. 3 using System.Text;
43. 4 using System.Threading;
44. 5
45. 6 namespace StartThread
46. 7 {
47. 8          class Program
48. 9          {
49. 10                  int interval = 200;
50. 11                  static void Main(string[] args)
51. 12                  {
52. 13                          Program p = new Program();
53. 14
54. 15                          Thread parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));
55. 16                          parameterThread.Name = "Thread A:";
56. 17                          parameterThread.Start(30);
57. 18                  }
58. 19
59. 20                  ///<summary>
60. 21 /// 带参数的启动方法
61. 22 ///</summary>
62. 23 ///<param name="ms">让线程在运行过程中的休眠间隔</param>
63. 24                  public void ParameterRun(object ms)
64. 25                  {
65. 26                          int j = 10;
66. 27                          int.TryParse(ms.ToString(), out j);//这里采用了TryParse方法，避免不能转换时出现异常
67. 28                          for (int i = 0; i < 10; i++)
68. 29                          {
69. 30                                  Console.WriteLine(Thread.CurrentThread.Name+"系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());
70. 31                                  Thread.Sleep(j);//让线程暂停
71. 32                          }
72. 33                  }
73. 34          }
74. 35 }
75. 在这个方法里，我们在启动线程时顺便指定了线程的暂停间隔，也就是这句：
76. parameterThread.Start(30);
77. 线程启动时运行的方法是public void ParameterRun(object ms)，这个值为30的int类型变量被装箱成object，所以在方法中还需要将它转换成int类型，这个可以通过拆箱或者其它办法解决。
78. 假如我们要启动两个线程，每个线程的暂停间隔不一样，启动代码如下：
79. 　　
80. 1 using System;
81. 2 using System.Collections.Generic;
82. 3 using System.Text;
83. 4 using System.Threading;
84. 5
85. 6 namespace StartThread
86. 7 {
87. 8          class Program
88. 9          {
89. 10                  int interval = 200;
90. 11                  static void Main(string[] args)
91. 12                  {
92. 13                          Program p = new Program();
93. 14
94. 15                          Thread parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));
95. 16                          parameterThread.Name = "Thread A:";
96. 17                          parameterThread.Start(30);
97. 18                          //启动第二个线程
98. 19                          parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));
99. 20                          parameterThread.Name = "Thread B:";
100. 21                          parameterThread.Start(60);
101. 22                  }
102. 23
103. 24                  ///<summary>
104. 25 /// 带参数的启动方法
105. 26 ///</summary>
106. 27 ///<param name="ms">让线程在运行过程中的休眠间隔</param>
107. 28                  public void ParameterRun(object ms)
108. 29                  {
109. 30                          int j = 10;
110. 31                          int.TryParse(ms.ToString(), out j);//这里采用了TryParse方法，避免不能转换时出现异常
111. 32                          for (int i = 0; i < 10; i++)
112. 33                          {
113. 34                                  Console.WriteLine(Thread.CurrentThread.Name+"系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());
114. 35                                  Thread.Sleep(j);//让线程暂停
115. 36                          }
116. 37                  }
117. 38          }
118. 39 }
119. 对上面的代码做一点说明，就是线程启动之后，线程的实例不必再存在，例如在上面的代码中我用的是同一个实例实例化了两个线程，并且这两个线程运行很正常。
120. 继续探索
121. 上面解决了一个问题，如果在启动线程时需要参数如何解决，如果针对上面的问题继续发掘，比如：在启动线程时不但要指定线程的暂停间隔，还需要指定循环次数（在上面的所有例子中都是执行10次的），这个问题该如何解决呢？
122. 有两种办法可以解决：
123. 首先可以继续在ParameterizedThreadStart这里做文章，因为这里可以使用一个Object类型的参数，那么可以通过数组或者一个类来解决（因为它们都是Object的子类）。我在做某个系统时确实采用数组处理过这种情况，这样就要求在线程启动方法中必须清楚知道数组中每个参数的用途，不是太方便。
124. 这里说说重新定义一个实体类来解决的方法，代码如下。
125. 1 using System;
126. 2 using System.Collections.Generic;
127. 3 using System.Text;
128. 4 using System.Threading;
129. 5
130. 6 namespace StartThread
131. 7 {
132. 8          class MyThreadParameter
133. 9          {
134. 10                  private int interval;
135. 11                  private int loopCount;
136. 12                  ///<summary>
137. 13 /// 循环次数
138. 14 ///</summary>
139. 15                  public int LoopCount
140. 16                  {
141. 17                          get { return loopCount; }
142. 18                  }
143. 19
144. 20                  ///<summary>
145. 21 /// 线程的暂停间隔
146. 22 ///</summary>
147. 23                  public int Interval
148. 24                  {
149. 25                          get { return interval; }
150. 26                  }
151. 27             ///<summary>
152. 28 /// 构造函数
153. 29 ///</summary>
154. 30 ///<param name="interval">线程的暂停间隔</param>
155. 31 ///<param name="loopCount">循环次数</param>
156. 32                  public MyThreadParameter(int interval,int loopCount)
157. 33                  {
158. 34                          this.interval = interval;
159. 35                          this.loopCount = loopCount;
160. 36                  }
161. 37          }
162. 38          class Program
163. 39          {
164. 40                  int interval = 200;
165. 41                  static void Main(string[] args)
166. 42                  {
167. 43                          Program p = new Program();
168. 44
169. 45                          Thread parameterThread = new Thread(new ParameterizedThreadStart(p.MyParameterRun));
170. 46                          parameterThread.Name = "Thread A:";
171. 47                          MyThreadParameter paramter = new MyThreadParameter(50, 20);
172. 48                          parameterThread.Start(paramter);
173. 49                  }
174. 50
175. 51
176. 52                  ///<summary>
177. 53 /// 带多个参数的启动方法
178. 54 ///</summary>
179. 55 ///<param name="ms">方法参数</param>
180. 56                  public void MyParameterRun(object ms)
181. 57                  {
182. 58                          MyThreadParameter parameter = ms as MyThreadParameter;//类型转换
183. 59                          if (parameter != null)
184. 60                          {
185. 61                                  for (int i = 0; i < parameter.LoopCount; i++)
186. 62                                  {
187. 63                                          Console.WriteLine(Thread.CurrentThread.Name + "系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());
188. 64                                          Thread.Sleep(parameter.Interval);//让线程暂停
189. 65                                  }
190. 66                          }
191. 67                  }
192. 68          }
193. 69 }
194. 第二种方法和上面方法有些相似，也是需要引入外部类，并且将Thread实例放在引入的类中，这种情况适合于在线程中处理的业务逻辑比较复杂的情况。在前不久处理的一个项目中我用过这种情况，它是用来实现双向数据传输的。
195. 如果实现上面的效果，代码如下：
196. 　　
197. 1 using System;
198. 2 using System.Collections.Generic;
199. 3 using System.Text;
200. 4 using System.Threading;
201. 5
202. 6 namespace StartThread
203. 7 {
204. 8          class MyThreadParameter
205. 9          {
206. 10                  private int interval;
207. 11                  private int loopCount;
208. 12                  private Thread thread;
209. 13
210. 14     ///<summary>
211. 15 /// 构造函数
212. 16 ///</summary>
213. 17 ///<param name="interval">线程的暂停间隔</param>
214. 18 ///<param name="loopCount">循环次数</param>
215. 19                  public MyThreadParameter(int interval,int loopCount)
216. 20                  {
217. 21                          this.interval = interval;
218. 22                          this.loopCount = loopCount;
219. 23                          thread = new Thread(new ThreadStart(Run));
220. 24                  }
221. 25
222. 26                  public void Start()
223. 27                  {
224. 28                          if (thread != null)
225. 29                          {
226. 30                                  thread.Start();
227. 31                          }
228. 32                  }
229. 33
230. 34                  private void Run()
231. 35                  {
232. 36                          for (int i = 0; i < loopCount; i++)
233. 37                          {
234. 38                                  Console.WriteLine("系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());
235. 39                                  Thread.Sleep(interval);//让线程暂停
236. 40                          }
237. 41                  }
238. 42          }
239. 43          class Program
240. 44          {
241. 45                  static void Main(string[] args)
242. 46                  {
243. 47                          MyThreadParameter parameterThread = new MyThreadParameter(30, 50);
244. 48                          parameterThread.Start();
245. 49                  }
246. 50
247. 51          }
248. 52 }
249. 上面的代码的运行效果和前面的代码运行效果类似，只不过是将业务处理代码放在一个单独的类MyThreadParameter中，使得MyThreadParameter看起来也像一个Thread，实际上维护的还是其内部的Thread，在一些大型系统中这样做的好处是便于维护。
250. 总结：在本篇主要讲述如何启动线程的问题，在启动时可能会遇到无需参数、需要多个参数的情况，在这里讲述了如何解决这些问题的思路。在.net类库中虽然存在着庞大的类库，但是并不是总会有合适的类来解决我们所遇到的问题，但是只要肯动脑筋总会想到合适的办法。