全部博文（372）
2012年（372）
分类： 虚拟化
2012-03-22 18:12:47
撰写多线程对象时，执行速度是一项很重要的设计考虑。通常为了加快执行速度，会将执行运作逻辑的主线程，跟发出事件的事件线程做隔离设计。这样的隔离设计可以不让主线程，因为外部事件处理而停顿。而这样的设计下，为了简化线程管理，可以采用ThreadPool来完成事件线程的工作。简单的程序范例如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64 |
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
var obj = new ClassA();
obj.NotifyArrived += new Action
obj.Start();
Console.ReadLine();
obj.Stop();
}
static void obj_NotifyArrived(int data)
{
Console.WriteLine(data);
}
}
public class ClassA
{
// Fields
private bool _isRunning = true;
// Methods
public void Start()
{
Thread thread = new Thread(this.Run);
thread.Start();
}
public void Stop()
{
_isRunning = false;
}
private void Run()
{
int i = 0;
while (_isRunning == true)
{
Thread.Sleep(100);
this.OnNotifyArrived(i++);
}
}
// Events
public event System.Action
private void OnNotifyArrived(int data)
{
WaitCallback handlerDelegate = delegate(object state)
{
var handler = this.NotifyArrived;
if (handler != null)
{
handler(data);
}
};
ThreadPool.QueueUserWorkItem(handlerDelegate);
}
}
} |
但是这样的隔离设计，却无法满足「必须按照先来后到去处理事件」这样的行为要求。因为ThreadPool只是单纯的为每一个WaitCallback委派，分派一条线程去做处理，而每条线程之间并没有设定执行先后顺序的能力。
这个问题困扰了我几天，后来想到一个解法。在主线程跟事件线程之间，垫一层Queue做隔离，将要执行的WaitCallback委派都存放进这个Queue。并且通过Lock的机制，强迫一次只能有一个线程去处理Queue里面的WaitCallback委派。透过这样的设计，就可以完成将执行运作逻辑的主线程，跟发出事件的事件线程做隔离设计的工作。范例程序代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95 |
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
var obj = new ClassB();
obj.NotifyArrived += new Action
obj.Start();
Console.ReadLine();
obj.Stop();
}
static void obj_NotifyArrived(int data)
{
Console.WriteLine(data);
}
}
public class ClassB
{
// Fields
private bool _isRunning = true;
private readonly object _eventSyncRoot = new object();
private readonly Queue
// Methods
public void Start()
{
Thread thread = new Thread(this.Run);
thread.Start();
}
public void Stop()
{
_isRunning = false;
}
private void Run()
{
int i = 0;
while (_isRunning == true)
{
Thread.Sleep(100);
this.OnNotifyArrived(i++);
}
}
// Events
public event System.Action
private void OnNotifyArrived(int data)
{
// Queue EventDelegate
WaitCallback eventDelegate = delegate(object state)
{
var handler = this.NotifyArrived;
if (handler != null)
{
handler(data);
}
};
lock (_eventDelegateQueue)
{
_eventDelegateQueue.Enqueue(eventDelegate);
}
// Run EventDelegate
WaitCallback handlerDelegate = delegate(object state)
{
lock (_eventSyncRoot)
{
WaitCallback runEventDelegate = null;
lock (_eventDelegateQueue)
{
if (_eventDelegateQueue.Count > 0)
{
runEventDelegate = _eventDelegateQueue.Dequeue();
}
}
if (runEventDelegate != null)
{
runEventDelegate(null);
}
}
};
ThreadPool.QueueUserWorkItem(handlerDelegate);
}
}
} |
最后说一下，要完成这样的隔离设计。不使用ThreadPool，而改用一个独立Thread去处理WaitCallback委派，也是可行的设计。只不过独立一个线程去处理，就需要额外增加管理这个独立线程的工作，这就看每个人的选择跟考虑了。
