C#中如果正确使用线程Task类和Thread类

野性酷女 2022-07-24 09:21 66阅读 0赞

**http://blog.csdn.net/zhengxu25689/article/details/39368485**

**C\#中使用线程Task类和Thread类小结**

刚接触[C\#][C]3个月左右，原先一直使用C++开发，因为公司的需要，所地采用C\#开发，主要是控制设备的实时性操作，此为背景。

对于C\#中的Task和Thread我在这不作介绍，要了解更多的，如果查看相当信息。此次项目中使用到TASK和THRED，让我调试足足用了将近两周的时间才找出问题所在，所以在此写出来防止跟我一样刚接触C\#，又同时需要对线程的实时性要求的开发人员一些个人总结注意事项。

1.Task适合用于多处理器，且i系列多处理器。

2.Thread则适用于所有的处理器，实时性更高。

下面是我的个人测试代码：

其中使用的对错可能是我个人对C\#线程理解不够引起的，如果有使用不正确错，望大鸟指导。

**\[csharp\]**  [view plain][]   [copy][view plain]

1.         **private** **static** **void** ThreadAndTaskTest()  
2.         \{  
3.             Stopwatch watch = **new** Stopwatch();  
4.             watch.Start();  
5.   
6.             //Thread threadTest1 = new Thread(() =>  
7.             //\{   
8.             //    Thread.Sleep(2000);  
9.             //    Debug.WriteLine("线程1结束消耗时间：\{0\}", watch.ElapsedMilliseconds);  
10.             //\});  
11.             //threadTest1.Start();            //Thread threadTest2 = new Thread(() =>  
12.             //\{   
13.             //    Thread.Sleep(2000);  
14.             //    Debug.WriteLine("线程2结束消耗时间：\{0\}", watch.ElapsedMilliseconds);  
15.             //\});  
16.             //threadTest2.Start();            //Thread threadTest3 = new Thread(() =>  
17.             //\{   
18.             //    Thread.Sleep(2900);  
19.             //    Debug.WriteLine("线程2结束消耗时间：\{0\}", watch.ElapsedMilliseconds);  
20.             //\});  
21.             //threadTest3.Start();             var Task1 = Task.Factory.StartNew(() =>  
22.             \{  
23.                 Thread.Sleep(2500);  
24.                 Debug.WriteLine("线程1结束消耗时间：\{0\}", watch.ElapsedMilliseconds);  
25.             \});  
26.   
27.             var Task2 = Task.Factory.StartNew(() =>  
28.             \{  
29.                 Thread.Sleep(2700);  
30.                 Debug.WriteLine("线程2结束消耗时间：\{0\}", watch.ElapsedMilliseconds);  
31.             \});  
32.   
33.             var Task3 = Task.Factory.StartNew(() =>  
34.             \{  
35.                 Thread.Sleep(2900);  
36.                 Debug.WriteLine("线程3结束消耗时间：\{0\}", watch.ElapsedMilliseconds);  
37.             \});  
38.   
39.             **while** (watch.ElapsedMilliseconds <= 3000)  
40.             \{  
41.                 //if (!threadTest.IsAlive && !threadTest1.IsAlive)  
42.                 **if** (Task1.IsCompleted && Task2.IsCompleted && Task3.IsCompleted)  
43.                 \{  
44.                     Debug.WriteLine("监控结束消耗时间：\{0\}", watch.ElapsedMilliseconds);  
45.                     **break**;  
46.                 \}  
47.                 **else**  
48.                     Thread.Sleep(1);  
49.             \}  
50.         \}

上面采用Task测试结果如下：

线程1结束消耗时间：2503  
             线程2结束消耗时间：2703  
             线程3结束消耗时间：3944(理论应该2905)

同样的代码采用Thread的测试结如下：

线程2结束消耗时间：2003  
             线程1结束消耗时间：2002  
             线程2结束消耗时间：2905

上面测试环境在:

处理器：Pentium（R）Dual-Core CPU E6700 @3.20GHXZ

安装内存（RAM）：4.0GB

系统类型：32位操作系统

如果采用 i5系列的CPU，其它硬件环境都一样则不会有这种超时情况.

在此也遇到点问题：线程20个以上同时运行，线程的实时性差异也很大，同一个线程函数差距有700ms.

[C]: http://lib.csdn.net/base/25
[view plain]: http://blog.csdn.net/zhengxu25689/article/details/39368485#