多核时代下的多线程编程----帮大家读懂TThread类

TThread类在Delphi的RTL里算是比较简单的类，类成员也不多，类属性都很简单明白，本文将只对几个比较重要的类成员方法和唯一的事件：OnTerminate作详细分析。

首先就是构造函数：

 

constructor TThread.Create(CreateSuspended: Boolean);

begin

inherited Create;

AddThread;

FSuspended := CreateSuspended;

FCreateSuspended := CreateSuspended;

FHandle := BeginThread(nil, 0, @ThreadProc, Pointer(Self), CREATE_SUSPENDED, FThreadID);

if FHandle = 0 then

raise EThread.CreateResFmt(@SThreadCreateError, [SysErrorMessage(GetLastError)]);

end;

虽然这个构造函数没有多少代码，但却可以算是最重要的一个成员，因为线程就是在这里被创建的。

在通过Inherited调用TObject.Create后，第一句就是调用一个过程：AddThread，其源码如下：

procedure AddThread;

begin

InterlockedIncrement(ThreadCount);

end;

同样有一个对应的RemoveThread：

procedure RemoveThread;

begin

InterlockedDecrement(ThreadCount);

end;

它们的功能很简单，就是通过增减一个全局变量来统计进程中的线程数。只是这里用于增减变量的并不是常用的Inc/Dec过程，而是用了InterlockedIncrement/InterlockedDecrement这一对过程，它们实现的功能完全一样，都是对变量加一或减一。但它们有一个最大的区别，那就是InterlockedIncrement/InterlockedDecrement是线程安全的。即它们在多线程下能保证执行结果正确，而Inc/Dec不能。或者按操作系统理论中的术语来说，这是一对“原语”操作。

 

 

接下来最重要就是这句了：

FHandle := BeginThread(nil, 0, @ThreadProc, Pointer(Self), CREATE_SUSPENDED, FThreadID);

 

BeginThread，它有很多参数，关键的是第三、四两个参数。第三个参数就是前面说到的线程函数，即在线程中执行的代码部分。第四个参数则是传递给线程函数的参数，在这里就是创建的线程对象（即Self）。其它的参数中，第五个是用于设置线程在创建后即挂起，不立即执行（启动线程的工作是在AfterConstruction中根据CreateSuspended标志来决定的），第六个是返回线程ID。

现在来看TThread的核心：线程函数ThreadProc。特别要注意的是ThreadProc这个线程类的核心不是线程的成员，而是一个全局函数（因为BeginThread过程的参数约定只能用全局函数）。下面是它的代码：

 

function ThreadProc(Thread: TThread): Integer;

var

FreeThread: Boolean;

begin

try

if not Thread.Terminated then

try

Thread.Execute;

except

Thread.FFatalException := AcquireExceptionObject;

end;

finally

FreeThread := Thread.FFreeOnTerminate;

Result := Thread.FReturnValue;

Thread.DoTerminate;

Thread.FFinished := True;

SignalSyncEvent;

if FreeThread then Thread.Free;

EndThread(Result);

end;

end;

 

 

 

虽然也没有多少代码，但却是整个TThread中最重要的部分，因为这段代码是真正在线程中执行的代码。下面对代码作逐行说明：

1、首先判断线程类的Terminated标志，如果未被标志为终止，则调用线程类的Execute方法执行线程代码，因为TThread是抽象类，Execute方法是抽象方法，所以本质上是执行派生类中的Execute代码。

2、Execute就是线程类中的线程函数，所有在Execute中的代码都需要当作线程代码来考虑，如防止访问冲突等。

3、如果Execute发生异常，则通过AcquireExceptionObject取得异常对象，并存入线程类的FFatalException成员中。

4、最后是线程结束前做的一些收尾工作。局部变量FreeThread记录了线程类的FreeOnTerminated属性的设置，然后将线程返回值设置为线程类的返回值属性的值。

5、接下来执行线程类的DoTerminate方法。

DoTerminate方法的代码如下：

 

procedure TThread.DoTerminate;

begin

if Assigned(FOnTerminate) then Synchronize(CallOnTerminate); //一定要注意这里是用同步主线程的形式来调用的

end;

 

很简单，就是通过Synchronize来调用CallOnTerminate方法，而CallOnTerminate方法的代码如下，就是简单地调用OnTerminate事件：

 

procedure TThread.CallOnTerminate;

begin

if Assigned(FOnTerminate) then FOnTerminate(Self);

end;

 

因为OnTerminate事件是在Synchronize中执行的，所以本质上它并不是线程代码，而是主线程代码（具体见后面对Synchronize的分析）。

执行完OnTerminate后，将线程类的FFinished标志设置为True。

接下来执行SignalSyncEvent过程，其代码如下：

 

procedure SignalSyncEvent;

begin

SetEvent(SyncEvent);

end;

 

6、SignalSyncEvent也很简单，就是设置一下一个全局Event：SyncEvent，关于Event的使用，而SyncEvent的用途将在WaitFor过程中说明。

7、然后根据FreeThread中保存的FreeOnTerminate设置决定是否释放线程类，在线程类释放时，还有一些些操作，详见接下来的析构函数实现。

8、最后调用EndThread结束线程，返回线程返回值。

至此，线程完全结束。

 

 

说完构造函数，再来看析构函数：

destructor TThread.Destroy;

begin

if (FThreadID <> 0) and not FFinished then

begin

Terminate;

if FCreateSuspended then

Resume;

WaitFor;

end;

RemoveQueuedEvents(Self, nil);

if FHandle <> 0 then CloseHandle(FHandle); //关闭线程Handle

inherited Destroy;

FFatalException.Free;

RemoveThread;

end;

 

在线程对象被释放前，首先要检查线程是否还在执行中，如果线程还在执行中（线程ID不为0，并且线程结束标志未设置），则调用Terminate过程结束线程。Terminate过程只是简单地设置线程类的Terminated标志，如下面的代码：

 

procedure TThread.Terminate;

begin

FTerminated := True;

end;

 

线程结束后，关闭线程Handle（正常线程创建的情况下Handle都是存在的），释放操作系统创建的线程对象。

然后调用TObject.Destroy释放本对象，并释放已经捕获的异常对象，

最后调用RemoveThread减小进程的线程数。

 

 

 

至此我们知道了线程要结束必须等待线程的Execute方法执行完毕，所以一般来说，要让你的线程能够尽快终止，必须在Execute方法中在较短的时间内不断地检查Terminated标志，以便能及时地退出。这是设计线程代码的一个很重要的原则！

 

 

接下来我们讲讲线程同步的一些方法：

1、事件（Event），可以这么理解Event其实相当于一个全局的布尔变量。它有两个赋值操作：Set和Reset，相当于把它设置为True或False。而检查它的值是通过WaitFor操作进行。对应在Windows平台上，是三个API函数：SetEvent、ResetEvent、WaitForSingleObject（实现WaitFor功能的API还有几个，这是最简单的一个）。这三个都是原语操作，所以Event可以实现一般布尔变量不能实现的在多线程中的应用。Set和Reset的功能比较简单，现在来说一下WaitFor的功能：

WaitFor的功能是检查Event的状态是否是Set状态（相当于True），如果是则立即返回，如果不是，则等待它变为Set状态，在等待期间，调用WaitFor的线程处于挂起状态。另外WaitFor有一个参数用于超时设置，如果此参数为0，则不等待，立即返回Event的状态，如果是INFINITE则无限等待，直到Set状态发生，若是一个有限的数值，则等待相应的毫秒数后返回Event的状态。

当Event从Reset状态向Set状态转换时，唤醒其它由于WaitFor这个Event而挂起的线程。

 

2、临界区（CriticalSection）则是一项共享数据访问保护的技术。它其实也是相当于一个全局的布尔变量。但对它的操作有所不同，它只有两个操作：Enter和Leave，同样可以把它的这两个状态当作True和False，分别表示现在是否处于临界区中。这两个操作也是原语，所以它可以用于在多线程应用中保护共享数据，防止访问冲突。

用临界区保护共享数据的方法很简单：在每次要访问共享数据之前调用Enter设置进入临界区标志，然后再操作数据，最后调用Leave离开临界区。它的保护原理是这样的：当一个线程进入临界区后，如果此时另一个线程也要访问这个数据，则它会在调用Enter时，发现已经有线程进入临界区，然后此线程就会被挂起，等待当前在临界区的线程调用Leave离开临界区，当另一个线程完成操作，调用Leave离开后，此线程就会被唤醒，并设置临界区标志，开始操作数据，这样就防止了访问冲突。

3、最后要说明一点，Event和CriticalSection都是操作系统资源，使用前都需要创建，使用完后也同样需要释放。如TThread类用到的一个全局Event：SyncEvent和全局CriticalSection：TheadLock，都是在InitThreadSynchronization和DoneThreadSynchronization中进行创建和释放的，而它们则是在Classes单元的Initialization和Finalization中被调用的。

4、由于在TThread中都是用API来操作Event和CriticalSection的，所以前面都是以API为例，其实Delphi已经提供了对它们的封装，在SyncObjs单元中，分别是TEvent类和TCriticalSection类。用法也与前面用API的方法相差无几。因为TEvent的构造函数参数过多，为了简单起见，Delphi还提供了一个用默认参数初始化的Event类：TSimpleEvent。

 

 

 

OK, 有了前面对Event和CriticalSection的准备知识，可以正式开始讨论Synchronize和WaitFor了。

我们知道，Synchronize是通过将部分代码放到主线程中执行来实现线程同步的，因为在一个进程中，只有一个主线程。先来看看Synchronize的实现：

 

procedure TThread.Synchronize(AMethod: TThreadMethod);

begin

FSynchronize.FThread := Self;

FSynchronize.FSynchronizeException := nil;

FSynchronize.FMethod := AMethod;

Synchronize(@FSynchronize); //调用重载版本

end;

 

其中FSynchronize是一个记录类型：

PSynchronizeRecord = ^TSynchronizeRecord;

TSynchronizeRecord = record

FThread: TObject;

FMethod: TThreadMethod;

FSynchronizeException: TObject;

end;

 

TsynchronizeRecord记录类型是非常重要的：用于进行线程和主线程之间进行数据交换，包括传入线程类对象，同步方法及发生的异常。

 

在Synchronize中调用了它的一个重载版本，而且这个重载版本比较特别，它是一个“类方法”。

所谓类方法，是一种特殊的类成员方法，它的调用并不需要创建类实例，而是像构造函数那样，通过类名调用。

之所以会用类方法来实现它，是因为为了可以在线程对象没有创建时也能调用它。

下面是这个Synchronize的代码：

 

 

 

class procedure TThread.Synchronize(ASyncRec: PSynchronizeRecord; QueueEvent: Boolean = False);

var

SyncProc: TSyncProc;

SyncProcPtr: PSyncProc;

begin

if GetCurrentThreadID = MainThreadID then //判断线程是否是主线程

ASyncRec.FMethod

else

begin

if QueueEvent then

New(SyncProcPtr)

else

SyncProcPtr := @SyncProc;

if not QueueEvent then

SyncProcPtr.Signal := CreateEvent(nil, True, False, nil)

else

SyncProcPtr.Signal := 0;

try

EnterCriticalSection(ThreadLock);

try

SyncProcPtr.Queued := QueueEvent;

if SyncList = nil then

SyncList := TList.Create;

SyncProcPtr.SyncRec := ASyncRec;

SyncList.Add(SyncProcPtr);

 

//与CheckSynchronize里的ResetSyncEvent相对应，在Linux下才有用。

//当前线程如果被主线程WaitFor 这句也是很关键的，它使MsgWaitForMultipleObjects能够返回

SignalSyncEvent; //注意SyncEvent是定义在Classes.pas单元的全局变量：SyncEvent: THandle;

 

if Assigned(WakeMainThread) then

WakeMainThread(SyncProcPtr.SyncRec.FThread); //投递完消息后会调用CheckSynchronize，而CheckSynchronize又会用到ThreadLock

if not QueueEvent then

begin

LeaveCriticalSection(ThreadLock); //这里请大家注意了，调用WaitForSingleObject前先退出临界区，目的就是防止线程死锁

try

WaitForSingleObject(SyncProcPtr.Signal, INFINITE);

finally

EnterCriticalSection(ThreadLock);

end;

end;

finally

LeaveCriticalSection(ThreadLock);

end;

finally

if not QueueEvent then

CloseHandle(SyncProcPtr.Signal);

end;

if not QueueEvent and Assigned(ASyncRec.FSynchronizeException) then

raise ASyncRec.FSynchronizeException;

end;

end;

 

 

这段代码略多一些，不过也不算太复杂。

1、首先是判断当前线程是否是主线程，如果是，则简单地执行同步方法后返回。

如果不是主线程，则准备开始同步过程。

通过局部变量SyncProc记录在线程之前交换数据（参数）和一个Event Handle，其记录结构如下：

TSyncProc = record

SyncRec: PSynchronizeRecord;

Signal: THandle;

end;

 

2、然后创建一个Event，接着进入临界区，然后就是把这个记录数据存入SyncList这个列表中（如果这个列表不存在的话，则创建它）。可见ThreadLock这个临界区就是为了保护对SyncList的访问，这一技巧在后面介绍CheckSynchronize时会再次看到。

 

3、再接下就是调用SignalSyncEvent，其代码在前面介绍TThread的构造函数时已经介绍过了，它的功能就是简单地将SyncEvent作一个Set的操作。关于这个SyncEvent的用途，将在后面介绍WaitFor时再详述。

4、接下来就是最主要的部分了：调用WakeMainThread事件进行同步操作。WakeMainThread在Tthread线程里并没有实现它，那它是来自哪里呢？？大家可以用搜索的方法喽，可以找到是在Forms单元里进行的设置，如下两个过程：

 

procedure TApplication.HookSynchronizeWakeup;

begin

Classes.WakeMainThread := WakeMainThread;

end;

 

procedure TApplication.UnhookSynchronizeWakeup;

begin

Classes.WakeMainThread := nil;

end;

 

上面两个方法分别是在TApplication类的构造函数和析构函数中被调用。

这就是在Application对象中WakeMainThread事件响应的代码，消息就是在这里被发出的，它利用了一个空消息来实现：

 

procedure TApplication.WakeMainThread(Sender: TObject);

begin

PostMessage(Handle, WM_NULL, 0, 0);

end;

 

WakeMainThread是一个TNotifyEvent类型的全局事件。这里之所以要用事件进行处理，是因为Synchronize方法本质上是通过消息，将需要同步的过程放到主线程中执行，如果在一些没有消息循环的应用中（如Console或DLL）是无法使用的，所以要使用这个事件进行处理。

 

5、同时这个消息的响应也是在Application对象中实现的，见下面的代码（删除无关的部分）：

procedure TApplication.WndProc(var Message: TMessage);

…

begin

try

…

with Message do

case Msg of

…

WM_NULL:

CheckSynchronize;

…

except

HandleException(Self);

end;

end;

其中的CheckSynchronize也是定义在Classes单元中的，由于它比较复杂，我们后面再来讲，现在只要知道它是具体处理Synchronize功能的部分就好，现在继续分析Synchronize的代码。

6、在执行完WakeMainThread事件后，就退出临界区，然后调用WaitForSingleObject开始等待在进入临界区前创建的那个Event。这个Event的功能是等待这个同步方法的执行结束，关于这点，在后面分析CheckSynchronize时会再说明。

7、最后释放开始时创建的Event，如果被同步的方法返回异常的话，还会在这里再次抛出异常。

8、接下来来讲前面没讲的那个CheckSynchronize，见下面的代码：

 

function CheckSynchronize(Timeout: Integer = 0): Boolean;

var

SyncProc: PSyncProc;

LocalSyncList: TList;

begin

if GetCurrentThreadID <> MainThreadID then

raise EThread.CreateResFmt(@SCheckSynchronizeError, [GetCurrentThreadID]);

if Timeout > 0 then

WaitForSyncEvent(Timeout)

else

ResetSyncEvent; //注意SyncEvent是定义在Classes.pas单元的全局变量：SyncEvent: THandle;

LocalSyncList := nil;

EnterCriticalSection(ThreadLock); //进入临界区

try

Integer(LocalSyncList) := InterlockedExchange(Integer(SyncList), Integer(LocalSyncList));

try

Result := (LocalSyncList <> nil) and (LocalSyncList.Count > 0);

if Result then

begin

while LocalSyncList.Count > 0 do

begin

SyncProc := LocalSyncList[0]; //终于在这里进行线程间的信息传递了

LocalSyncList.Delete(0);

LeaveCriticalSection(ThreadLock);

try

try

SyncProc.SyncRec.FMethod; //执行同步方法

except

if not SyncProc.Queued then

SyncProc.SyncRec.FSynchronizeException := AcquireExceptionObject

else

raise;

end;

finally

EnterCriticalSection(ThreadLock);

end;

if not SyncProc.Queued then

SetEvent(SyncProc.Signal) //通知线程提交过来的需要同步的方法已经执行完了

else

begin

Dispose(SyncProc.SyncRec);

Dispose(SyncProc);

end;

end;

end;

finally

LocalSyncList.Free;

end;

finally

LeaveCriticalSection(ThreadLock);

end;

end;

 

 

1、首先，这个方法必须在主线程中被调用（如前面通过消息传递到主线程），否则就抛出异常。

2、接下来调用ResetSyncEvent（它与前面SetSyncEvent对应的，之所以不考虑WaitForSyncEvent的情况，是因为只有在Linux版下才会调用带参数的CheckSynchronize，Windows版下都是调用默认参数0的CheckSynchronize）。

3、现在可以看出SyncList的用途了：它是用于记录所有未被执行的同步方法的。因为主线程只有一个，而子线程可能有很多个，当多个子线程同时调用同4、接下来看对同步方法的处理：首先是从列表中移出（取出并从列表中删除）第一个同步方法调用数据。然后退出临界区（原因当然也是为了防止死锁）。

接着就是真正的调用同步方法了。如果同步方法中出现异常，将被捕获后存入同步方法数据记录中。

5、重新进入临界区后，调用SetEvent通知调用线程，同步方法执行完成了（详见前面Synchronize中的WaitForSingleObject调用）。

 

至此，整个Synchronize过程的实现介绍完成。

 

最后来说一下WaitFor，它的功能就是等待线程执行结束。其代码如下：

 

function TThread.WaitFor: LongWord;

var

H: array[0..1] of THandle;

WaitResult: Cardinal;

Msg: TMsg;

begin

H[0] := FHandle;

if GetCurrentThreadID = MainThreadID then

begin

WaitResult := 0;

H[1] := SyncEvent; //注意SyncEvent是定义在Classes.pas单元的全局变量：SyncEvent: THandle;

repeat

{ This prevents a potential deadlock if the background thread

does a SendMessage to the foreground thread }

if WaitResult = WAIT_OBJECT_0 + 2 then

PeekMessage(Msg, 0, 0, 0, PM_NOREMOVE);

WaitResult := MsgWaitForMultipleObjects(2, H, False, 1000, QS_SENDMESSAGE); //这里很重要

CheckThreadError(WaitResult <> WAIT_FAILED);

if WaitResult = WAIT_OBJECT_0 + 1 then

CheckSynchronize; //有线程进入同步的时候会调用

until WaitResult = WAIT_OBJECT_0;

end else WaitForSingleObject(H[0], INFINITE);

CheckThreadError(GetExitCodeThread(H[0], Result));

end;

 

 

1、如果不是在主线程中执行WaitFor的话，很简单，只要调用WaitForSingleObject等待此线程的Handle为Signaled状态即可。

2、如果是在主线程中执行WaitFor则比较麻烦。首先要在Handle数组中增加一个SyncEvent，然后循环等待，直到线程结束（即MsgWaitForMultipleObjects返回WAIT_OBJECT_0，详见MSDN中关于此API的说明）。

3、在循环等待中作如下处理：如果有消息发生，则通过PeekMessage取出此消息（但并不把它从消息循环中移除），然后调用MsgWaitForMultipleObjects来等待线程Handle或SyncEvent出现Signaled状态，同时监听消息（QS_SENDMESSAGE参数，详见MSDN中关于此API的说明）。可以把此API当作一个可以同时等待多个Handle的WaitForSingleObject。如果是SyncEvent被SetEvent（返回WAIT_OBJECT_0 + 1），则调用CheckSynchronize处理同步方法。

4、为什么在主线程中调用WaitFor必须用MsgWaitForMultipleObjects，而不能用WaitForSingleObject等待线程结束呢？因为防止死锁。由于在线程函数Execute中可能调用Synchronize处理同步方法，而同步方法是在主线程中执行的，如果用WaitForSingleObject等待的话，则主线程在这里被挂起，同步方法无法执行，导致线程也被挂起，于是发生死锁。而改用WaitForMultipleObjects则没有这个问题。因为：它的第三个参数为False，表示只要线程Handle或SyncEvent中只要有一个Signaled即可使主线程被唤醒，至于加上QS_SENDMESSAGE是因为Synchronize是通过消息传到主线程来的，所以还要防止消息被阻塞。这样，当线程中调用Synchronize时，主线程就会被唤醒并处理同步调用，在调用完成后继续进入挂起等待状态，直到线程结束。

 

至此，对线程类TThread的分析可以告一个段落了。