Chinaunix首页 | 论坛 | 博客
  • 博客访问: 835868
  • 博文数量: 372
  • 博客积分: 10063
  • 博客等级: 中将
  • 技术积分: 4220
  • 用 户 组: 普通用户
  • 注册时间: 2012-02-24 11:36
文章分类

全部博文(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_NotifyArrived);
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 NotifyArrived;
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_NotifyArrived);
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 _eventDelegateQueue = new 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 NotifyArrived;
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委派,也是可行的设计。只不过独立一个线程去处理,就需要额外增加管理这个独立线程的工作,这就看每个人的选择跟考虑了。

阅读(487) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~