C#中的Thread中的ApartmentState几种状态(STA，MTA，Unknown)详解

最新推荐文章于 2024-03-13 23:54:44 发布

七对

最新推荐文章于 2024-03-13 23:54:44 发布

阅读量2w

点赞数 5

分类专栏： asp.net(c#) 文章标签： thread c# 多线程 random object string

asp.net(c#) 专栏收录该内容

39 篇文章 1 订阅

订阅专栏

System.Threading命名空间是.Net多线程编程的基础。对于多线程编程在实际工作中一直用的不多，所以了解也就不多。尽管如此，随着多核，多个cpu的出现，大计算量的需要，多线程将越来越受关注。所以打算写个系列博客，以便更多的了解学习多线程的知识。听说.Net4.0中有一个更方便多线程的类库，可惜还没真的见识过，先熟悉System.Threading就当“温故而知新”了

从Thread的线程单元状态ApartmentState说起

ApartmentState是一个枚举变量，用来设置线程的单元状态（单元状态的ApartmentState的中文msdn翻译，这个翻译很水，我不能从这四个汉字中确切的了解英文ApartmentState要表达的意思）。ApartmentState有三个枚举值，分别为STA：表示Thread将被创建并进入一个单线程单元，我猜想STA应该是Single Thread Apartment的首字母简拼；MTA：表示Thread将被创建并进入一个多线程单元，还有一个是Unknown，表示没有设置线程的单元状态。我在以前使用Thread的时候，从来没有设置过线程的单元状态，今天要做个试验把这三种状态搞清楚。

使用新new 一个Thread实例之后可以使用SetAppartmentState方法设置线程的单元状态，每个线程只可以设置一次，若再次设置会抛异常，若不知道是否设置了单元状态可以使用Thread类提供的TrySetApartmentState方法来设置；不设置时其线程单元在控制台应用程序中默认是MTA。

试验思路：
1. 使用new 3个Thread的实例，什么都不执行，看两种不同的AppartmentState的Thread的执行顺序如何
2. 同样new 3个Thread实例，执行一段计算代码，看两种不同的AppartmentState执行完全部计算耗时情况

具体的实验代码如下：

C#代码
1.using System;
2.using System.Collections.Generic;
3.using System.Text;
4.using System.Threading;
5.using System.Diagnostics;
6.using System.Collections;
7.
8.namespace MutiThread
9.{
10. class Program
11. {
12. static Stopwatch swAll;
13. static Random r = new Random();
14. static Hashtable hashTable;
15.
16.
17. static void Main(string[] args)
18. {
19. Start3Thread(ApartmentState.STA);
20.
21. Console.ReadLine();
22. }
23.
24. static void Start3Thread(ApartmentState appartmentState)
25. {
26. int threadCn = 3;
27. hashTable = new Hashtable();
28. swAll = new Stopwatch();
29. swAll.Start();
30.
31. do
32. {
33. StartThread(appartmentState);
34. threadCn--;
35. } while (threadCn > 0);
36. }
37.
38. static void StartThread(ApartmentState appartmentState)
39. {
40. Thread t1 = new Thread(new ThreadStart(CalcSomething));
41.
42. //Thread t1 = new Thread(new ThreadStart(DoNothing));
43. hashTable.Add(t1.ManagedThreadId, false);
44. t1.SetApartmentState(appartmentState);
45. t1.Start();
46. }
47.
48.
49.
50. static void CalcSomething()
51. {
52. Stopwatch sw = new Stopwatch();
53. sw.Start();
54. int[] arr = new int[1000];
55. for (int i = 0; i < arr.Length; i++)
56. {
57. arr[i] = r.Next(1000);
58. }
59. //Console.WriteLine("线程" + Thread.CurrentThread.ManagedThreadId
60. // + "的单元状态是:" + Thread.CurrentThread.GetApartmentState()
61. // + "；线程状态：" + Thread.CurrentThread.ThreadState
62. // + "；耗时：" + sw.ElapsedTicks);
63. hashTable[Thread.CurrentThread.ManagedThreadId] = true;
64.
65. if (hashTable.Count == 3)
66. {
67. bool allFinish = true;
68. foreach (object key in hashTable.Keys)
69. {
70. allFinish = allFinish && (bool)hashTable[key];
71. }
72. if (allFinish)
73. {
74. swAll.Stop();
75. Console.WriteLine(Thread.CurrentThread.GetApartmentState().ToString() + "总耗时：" + swAll.ElapsedTicks);
76. if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA)
77. {
78. hashTable.Clear();
79. swAll.Reset();
80. swAll.Start();
81. Start3Thread(ApartmentState.MTA);
82. }
83. }
84. }
85. }
86.
87. static void DoNothing()
88. {
89. int times = 3;
90. do
91. {
92. Console.WriteLine("线程" + Thread.CurrentThread.ManagedThreadId
93. + "的单元状态是:" + Thread.CurrentThread.GetApartmentState()
94. + "；线程状态：" + Thread.CurrentThread.ThreadState);
95. times--;
96. } while (times > 0);
97. }
98. }
99.}
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Diagnostics;
using System.Collections;

namespace MutiThread
{
class Program
{
static Stopwatch swAll;
static Random r = new Random();
static Hashtable hashTable;

static void Main(string[] args)
{
Start3Thread(ApartmentState.STA);

Console.ReadLine();
}

static void Start3Thread(ApartmentState appartmentState)
{
int threadCn = 3;
hashTable = new Hashtable();
swAll = new Stopwatch();
swAll.Start();

do
{
StartThread(appartmentState);
threadCn--;
} while (threadCn > 0);
}

static void StartThread(ApartmentState appartmentState)
{
Thread t1 = new Thread(new ThreadStart(CalcSomething));

//Thread t1 = new Thread(new ThreadStart(DoNothing));
hashTable.Add(t1.ManagedThreadId, false);
t1.SetApartmentState(appartmentState);
t1.Start();
}

static void CalcSomething()
{
Stopwatch sw = new Stopwatch();
sw.Start();
int[] arr = new int[1000];
for (int i = 0; i < arr.Length; i++)
{
arr[i] = r.Next(1000);
}
//Console.WriteLine("线程" + Thread.CurrentThread.ManagedThreadId
// + "的单元状态是:" + Thread.CurrentThread.GetApartmentState()
// + "；线程状态：" + Thread.CurrentThread.ThreadState
// + "；耗时：" + sw.ElapsedTicks);
hashTable[Thread.CurrentThread.ManagedThreadId] = true;

if (hashTable.Count == 3)
{
bool allFinish = true;
foreach (object key in hashTable.Keys)
{
allFinish = allFinish && (bool)hashTable[key];
}
if (allFinish)
{
swAll.Stop();
Console.WriteLine(Thread.CurrentThread.GetApartmentState().ToString() + "总耗时：" + swAll.ElapsedTicks);
if (Thread.CurrentThread.GetApartmentState() == ApartmentState.STA)
{
hashTable.Clear();
swAll.Reset();
swAll.Start();
Start3Thread(ApartmentState.MTA);
}
}
}
}

static void DoNothing()
{
int times = 3;
do
{
Console.WriteLine("线程" + Thread.CurrentThread.ManagedThreadId
+ "的单元状态是:" + Thread.CurrentThread.GetApartmentState()
+ "；线程状态：" + Thread.CurrentThread.ThreadState);
times--;
} while (times > 0);
}
}
}

实验的结果是：
1. AppartmentState为STA或者MTA时的执行顺序都是不定的，每一次执行都可能不同，也就是说顺序上无法说明两种的区别。
2. 两种不同的ApartmentState的执行效率上是有区别的，单线程单元状态模式所耗时间明显多于多线程单元模式状态
3. 在不设置线程的AppartmentState时，默认值是MTA，也就是多线程模式的

我的测试CPU是单CPU的，具体如下：
Intel(R)Pentium(R)4CPU
3.00GHz
2.99GHz,1.99GB的内存