周六给公司做了个delphi技术培训，主要是中间层技术及多线程技术，2010-11-06

单元名

作用

BestSQL.pas

BestConst.pas

BestDes.pas

BestFunc.pas

gunFunSys.pas

Ado_ConnectionPool.pas

连接池单元，主要用于客户端OpenData

BHServerLib_Intf.pas

中间层接口单元

BHServerLib_Invk.pas

中间层接口代理单元

BH_MSSQL_Service_Impl.pas

中间层接口实现单元

fServerForm.pas

主窗口

Provider.pas

Unit_Global.pas

列表对象池单元，用于客户端OpenList

类名

重要属性方法

Ado_ConnectionPool.pas单元：

TConnObject池内对象类

TConnectionPools池对象类

DoIncObjects方法---------增加池内部对象组成单向链表

GetInstance方法----------从池里取可用的对象

ReleaseInstance方法----将使用后的对象还原回池

ReleaseInstances方法----供检测线程调用，用于关闭长时间没有使用的TConnObject对象的数据库连接（TMSConnection）

Unit_Global.pas单元：

TMyHashedStringList类

1、 先解读IniFiles.pas单元下的THashedStringList类

主要是看THashedStringList在修改删除时如何处理Hash值

2、TMyHashedStringList对THashedStringList的不足做了重要的调整，在大数据量的情况下性能提高很多

Unit_Global.pas单元：

TGroupObject池内对象类

TPoolGroupObject池对象类

IncObjects方法---------增加池内部对象组成双向链表

GetGroupObject方法----------从池里取可用的对象

ObjectsNoUseByStr和ObjectsSetCanUsed方法----将使用后的对象还原回池

CheckGroupObject方法----供检测线程调用，用于关闭长时间没有使用的TGroupObject对象

Unit_Global.pas单元：

TSafedStringList类

中间层就是用这个类来存储用户列表的。

我们都知道Delphi 本向是有一个TStringList类的，但是我可以查看一下TStringList类的实现代码，我们会发现TStringList不是线程安全的。中间层的一个首要任务就是要处理多用户并发的情况也就是要处理好多线程的线程安全问题，因些才重新写了这个TSafedStringList 类。它的继承关系是：

TSafedStringList = class(TObject)

当然了，你也可以直接从TStringList类继承下来，再改写相应的方法即可。

Server端

1、TROCustomSuperTcpServer.IntExecute 在其Create事件里有

fIndyServer := TIdTCPServer.Create(nil);

fIndyServer.OnExecute := IntExecute;

在IdCustomTCPServer.pas单元的TIdListenerThread.Run里调用

2、TROSCServerWorker.DoExecute; 会一直循环直到Client端断开。当Client端有数据请求的时候，会触发TROSCServerWorker.IncomingData事件

3、TROSCServerWorker.IncomingData 会接着触发TROCustomSuperTcpServer.HasData 事件

4、TROCustomSuperTcpServer.HasData 会执行TROInvokerQueueItem.Create 并将创建的对象执行 TROThreadPool.QueueItem

5、TROThreadPool.QueueItem 执行后最终会由TROPooledThread来调用TROInvokerQueueItem.Callback

6、终于在TROInvokerQueueItem.Callback里调用又回到TROCustomSuperTcpServer.DispatchMessage（其实是TROServer.DispatchMessage）

重点参考下图的调用过程

7、XXXX_Invk.pas单元定义的TXXXX_Invoker类是在MainProcessMessage单元里创建的。

function TROMessageDispatcher.ProcessMessage(const aTransport: IROTransport; aRequeststream, aResponsestream: TStream; out oResponseOptions: TROResponseOptions): boolean;

var

lMessage: IROMessage;

begin

lMessage := (MessageIntf as IROMessageCloneable).Clone(); //会创建一个TROBinMessage对象

result := MainProcessMessage(lMessage, aTransport, aRequeststream, aResponsestream, oResponseOptions);

//这里lMessage会被自动设置为 nil 从而Free了由(MessageIntf as IROMessageCloneable).Clone()创建的TROBinMessage对象

//这说明局部接口变量在过程或函数执行完后会被自动设置成nil

end;

8、MainProcessMessage函数里有代码来会用户的请求转为调用XXXX_Invk.pas里的相应的方法

factory := GetClassFactory(aMessage.InterfaceName);

result := factory.Invoker.HandleMessage(factory, aMessage, aTransport, oResponseOptions);

XXXX_Invk.pas里定义的类是在XXXX_Impl.pas单元的initialization注册到ClassFactoryList的

XXXX_Invk.pas里定义的类只会被Create一次

9、factory.Invoker.HandleMessage 就是 TROInvoker.HandleMessage 然后调用到 TROInvoker.CustomHandleMessage

10、在TROInvoker.CustomHandleMessage 里会创建 XXXX_Impl.pas定义的TRORemoteDataModule的子类，从而转向 去调用用户的代码

这说明： TRORemoteDataModule的子类是一直被Create和Free的，因此在这个类里定义类变量是没有意义的。

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的分析可以告一个段落了。