作者:linzhenqun(风)
时间:2006-2-6
Blog: http://blog.youkuaiyun.com/linzhengqun
-----------------------------------------------------------------------------------------------------
前言
上次写了一篇关于线程的文章，其中有介绍当工作线程有资源存在时，主线程如何释放工作线程的方法，后来仔细读了《Win32多线程程序设计》，对于线程的机制有了更进一步的理解，才知道那并非最佳的方法，这里将给出一个更好的方法，这也是我写这篇文章的最大原因。另外，对于同步机制也将作一些探讨。如果想全面了解多线程的，推荐看候捷翻译的《Win32多线程程序设计》。
干净地终止一个线程
回到上一篇的问题描述：如果线程中有一些资源，Execute正在使用这些资源，而主线程要释放这个线程，这个线程在释放的过程中会释放掉资源。想想会不会有问题呢，两个线程，一个在使用资源，一个在释放资源，会出现什么情况呢。具体的情况请看“线程杂谈”那篇文章。总之是出现了违法访问，而我给出的解决方法是使用一个FFinished成员，最后释放的时候循环判断FFinished，这样可以保证Execute执行完毕之前，线程的成员类不会被释放。利用线程类的Terminated属性和FFinished成员,便可在主线程干净结束工作线程。
但这并非最好的解决方法，循环判断FFinished成员即如下：
While not FFinished do
Sleep(100);
这并不能即时释放线程，最慢的情况还要等上0.1秒才能释放。而如果我们使用下面这种形式：
While not FFinished do
;
则是一种典型的Busy loop，主线程不停的使用While循环，非常浪费CPU的资源，这样的效率比直接等待慢一倍以上。
那么有没有一种方法，让主线程通知工作线程可以结束了，然后主线程等待工作线程结束，工作线程结束后才释放资源呢？让主线程通知工作线程结束可以用线程类的Terminated属性，这一点在上一篇文章已有介绍。而主线程等待Execute结束，事实上线程类的Destroy方法已经有这样的机制：
Terminate;
...
WaitFor;
其中的WaitFor方法一直等待直到Execute方法执行完毕（准确的说应该是ThreadProc函数执行完毕）。这些代码在一般的线程类中已经够用了，但有些线程类有自己的类成员，并会覆盖Destroy方法，在其中释放类成员，既然这样，我们可以把上面的代码包成一个方法，并在自己的 Destroy中首先调用该方法。这样即可即时干净地释放线程类，比使用循环更好。
下面给出例子：
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;
type
TMyClass = class
private
FTest: Integer;
public
procedure test;
end;
TMyThread = class(TThread)
private
FMyClass: TMyClass;
protected
(* 等待Execute方法执行完毕 *)
procedure WaitExecute;
procedure Execute; override;
public
constructor Create(CreateSuspended: Boolean);
destructor Destroy; override;
end;
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
private
{ Private declarations }
procedure OnTerminate(Sender: TObject);
public
{ Public declarations }
MyThread: TMyThread;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
{ TMyThread }
constructor TMyThread.Create(CreateSuspended: Boolean);
begin
inherited;
FMyClass := TMyClass.Create;
end;
destructor TMyThread.Destroy;
begin
WaitExecute;
FMyClass.Free;
FMyClass := nil;
inherited;
end;
procedure TMyThread.Execute;
begin
while not Terminated do
FMyClass.test;
end;
procedure TMyThread.WaitExecute;
begin
Terminate;
WaitFor;
end;
{ TMyClass }
procedure TMyClass.test;
begin
//用Sleep模拟业务操作
Sleep(100);
FTest := 0;
end;
procedure TForm1.Button1Click(Sender: TObject);
begin
MyThread := TMyThread.Create(False);
MyThread.OnTerminate := OnTerminate;
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
MyThread.Free;
end;
procedure TForm1.OnTerminate(Sender: TObject);
begin
ShowMessage('OK');
end;
end.
先点击Button1，然后点击Button2，线程类可以被正确地释放，试着把Destroy方法中的WaitExecute方法注释掉再点击按钮，接着关闭程序看看，这时就出现违法访问了。
同步机制
当有多个线程同时读写一个资源时，使用同步机制可以保护数据的完整性，也可以防止数据被损坏。线程同步有很多种方式，但最常用的还是临界区（Critical Sections），这里只讨论临界区。不过之前，先说明一下同步（Synchronous）和异步（Asynchronous）的概念。当程序1调用程序2时，程序1停止不动，直到程序2完成回到程序1来，程序1才继续下去，这就是同步；如果程序1调用程序2后，自己继续执行下去，那么两者之间就是异步。很明显多线程是一种异步执行方式，Windows系统的SendMessage和PostMessage分别是同步和异步方式。
一个TRTLCriticalSection类型的变量代表了一个临界区，引用《Windows高级编程》中的话，临界区就好像一个只能进一人的洗手间，后面的人只能排队等到进去的人出来才能进去。让我讲得详细一点，假设你有一个数据结构A会被线程B和C读写，则你可以声明一个 TRTLCriticalSection变量CS，接着调用InitializeCriticalSection(CS)，这时你拥有了一个临界区，在B 和C线程对A进行读写的地方，都套上如下的代码：
EnterCriticalSection(CS);
try
//对A进行读写
finally
LeaveCriticalSection(CS);
end;
你便能保证同一时间只有一个线程对A进行读写。
它的过程是这样的：
线程B和C一直在运行，某一时刻，B和C同时要对A进行操作，但事实上是不可能同时的，总有一个线程会快一点，假设是B吧，B线程的第一句便是 EnterCriticalSection(CS)，使得线程B进入了临界区，接着B对A进行操作。而操作系统总是这样频繁的在不同线程之间切换以制造 “多任务”的假象，当B对A的操作进行到一半时，系统将执行权切换给线程C，我们知道C也要对A进行操作，它的第一句也是 EnterCriticalSection(CS)，可是进这个“洗手间”时发现里面已经有“人”了，C没办法只能一直停在Enter的地方等候，过很短的时间，执行权交给了线程B，B继续对A进行操作，如此反复，B终于操作完了，最后调用LeaveCriticalSection(CS)离开“洗手间”，这时执行权再交到C时，C发现B已经离开临界区，它终于可以进入临界区对于A进行操作了，而此时别的线程要对A进行操作，也只能等C离开“洗手间”。
对于临界区有些地方值得注意：
1. 一个TRTLCriticalSection变量代表一个临界区，如果你使用两个这样的变量，则它们是毫不相干的，就像两个“洗手间”一样，对于同一个资源不能起到同步的作用。
2. 不要针对多个资源只声明一个Critical Section，这样使每一时刻只能对一个资源进行读写，会对程序的效率有很大的影响。为每个需要同步保护的资源声明一个临界区变量。
3. 需要对资源进行同步保护，则所有对资源操作的地方都要有Enter和Leave函数，且要有Try..finally结构，保证最后能Leave。
4. 在临界区里面不要进行非常费时的操作，更重要的防止死锁的发生。
死锁
线程同步虽好，但也带来一些问题，最典型的就是死锁，死锁通常发生在线程之间相互等待的情况下。拿临界区来说，假设有两个临界区，两个线程分别进入一个临界区，接着各自又要进入另一个临界区，这时就会落入“你等我，我等你”的轮回。下面我制造这种场景给你给看看：
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
const
WM_MYMESSAGE = WM_USER + 001;
type
TMyThread1 = class(TThread)
protected
procedure Execute; override;
end;
TMyThread2 = class(TThread)
protected
procedure Execute; override;
end;
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
private
{ Private declarations }
public
{ Public declarations }
Thd1: TMyThread1;
Thd2: TMyThread2;
end;
var
Form1: TForm1;
CS1, CS2: TRTLCriticalSection;
implementation
{$R *.dfm}
procedure DeadLock(var CSA, CSB: TRTLCriticalSection);
begin
EnterCriticalSection(CSA);
Sleep(100);
EnterCriticalSection(CSB);
try
Sleep(1000);
finally
LeaveCriticalSection(CSA);
LeaveCriticalSection(CSB);
end;
end;
{ TMyThread }
procedure TMyThread1.Execute;
begin
DeadLock(CS1, CS2);
end;
{ TMyThread2 }
procedure TMyThread2.Execute;
begin
DeadLock(CS2, CS1);
end;
{ TForm1 }
procedure TForm1.Button1Click(Sender: TObject);
begin
Thd1.Resume;
Thd2.Resume;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
InitializeCriticalSection(CS1);
InitializeCriticalSection(CS2);
Thd1 := TMyThread1.Create(True);
Thd2 := TMyThread2.Create(True);
end;
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
DeleteCriticalSection(CS1);
DeleteCriticalSection(CS2);
Thd1.Free;
Thd2.Free;
end;
end.
运行上面程序，点击按钮1，你的程序没有什么异样，但关闭程序看看，程序关闭不了，因为两个线程落到相互等待的局面，而线程的Free又在等Execute结束，所以程序没有办法关闭了。
让我说说为什么会发生死锁，点击Button1时，两个线程同时启动，TMyThread1执行了DeadLock(CS1, CS2)，而TMyThread2执行了DeadLock(CS2, CS1)，注意到两个参数倒过来了。
它的过程是这样，首先线程1先执行DeadLock，第一个进入EnterCriticalSection(CSA)，注意这里的CSA是CS1，接下来Sleep(100)，在线程1睡觉到一般时，线程2得到执行权也执行DeadLock，它也进入EnterCriticalSection (CSA)，这里的CSA却是CS2，接着线程2也Sleep(100)，也是睡到一半，换到线程1，线程1睡醒后往下执行，它要Enter到CSB，对于线程1来说，CSB是CS2，但CS2已经被线程2给Enter了，所以线程1挂起等待线程2离开CS2临界区；接着线程2醒来要进入 EnterCriticalSection(CSB)，这里的CSB是CS1，但CS1给线程1进入了，所以线程2也挂起等待线程1离开CS1临界区。就这样，两个线程相互等待，没完没了。
这就是死锁发生的情况之一，当多个临界区一起工作时，死锁就有可能发生，这是要特别注意的，在死锁可能发生的地方，尽量只用一个临界区。
后记
关于线程的杂谈就到这里了，这两篇线程的文章更关注于其应用。
如果要学习Delphi中的TThread对于线程机制的封装，推荐给你一篇技术文章：http://www.delphibbs.com/keylife/iblog_show.asp?xid=19903，非常精彩，我在其中也学到很多。
至于要系统学习多线程原理的，首推《Win32多线程程序设计》
另外，《Windows高级编程》对于线程的篇章也非常好。
Bye！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
