Delphi中的線程類的分析

轉貼于 華夏黑客同盟 http://www.77169.org

Delphi中有一個線程類TThread是用來實作多線程程式設計的，這個絕大多數Delphi書藉都有說到，但基本上都是對

TThread類的幾個成員作一簡單介紹，再說明一下Execute的實作和Synchronize的用法就完了。然而這并不是多線程編

程的全部，我寫此文的目的在于對此作一個補充。

線程本質上是程序中一段并發運作的代碼。一個程序至少有一個線程，即所謂的主線程。同時還可以有多個子線程。

當一個程序中用到超過一個線程時，就是所謂的“多線程”。

那麼這個所謂的“一段代碼”是如何定義的呢？其實就是一個函數或過程（對Delphi而言）。

如果用Windows API來建立線程的話，是通過一個叫做CreateThread的API函數來實作的，它的定義為：

HANDLE CreateThread(

    LPSECURITY_ATTRIBUTES lpThreadAttributes,

    DWORD dwStackSize,

    LPTHREAD_START_ROUTINE lpStartAddress,

    LPVOID lpParameter,

    DWORD dwCreationFlags,

    LPDWORD lpThreadId

);

其各參數如它們的名稱所說，分别是：線程屬性（用于在NT下進行線程的安全屬性設定，在9X下無效），堆棧大小，

起始位址，參數，建立标志（用于設定線程建立時的狀态），線程ID，最後傳回線程Handle。其中的起始位址就是線

程函數的入口，直至線程函數結束，線程也就結束了。

因為CreateThread參數很多，而且是Windows的API，是以在C Runtime Library裡提供了一個通用的線程函數（理論上

可以在任何支援線程的OS中使用）：

unsigned long _beginthread(void (_USERENTRY *__start)(void *), unsigned __stksize, void *__arg);

Delphi也提供了一個相同功能的類似函數：

function BeginThread(

    SecurityAttributes: Pointer;

    StackSize: LongWord;

    ThreadFunc: TThreadFunc;

    Parameter: Pointer;

    CreationFlags: LongWord;

    var ThreadId: LongWord

): Integer;

這三個函數的功能是基本相同的，它們都是将線程函數中的代碼放到一個獨立的線程中執行。線程函數與一般函數的

最大不同在于，線程函數一啟動，這三個線程啟動函數就傳回了，主線程繼續向下執行，而線程函數在一個獨立的線

程中執行，它要執行多久，什麼時候傳回，主線程是不管也不知道的。

正常情況下，線程函數傳回後，線程就終止了。但也有其它方式：

Windows API：

VOID ExitThread( DWORD dwExitCode );

C Runtime Library：

void _endthread(void);

Delphi Runtime Library：

procedure EndThread(ExitCode: Integer);

為了記錄一些必要的線程資料（狀态/屬性等），OS會為線程建立一個内部Object，如在Windows中那個Handle便是這

個内部Object的Handle，是以線上程結束的時候還應該釋放這個Object。

雖然說用API或RTL(Runtime Library)已經可以很友善地進行多線程程式設計了，但是還是需要進行較多的細節處理，為此

Delphi在Classes單元中對線程作了一個較好的封裝，這就是VCL的線程類：TThread

使用這個類也很簡單，大多數的Delphi書籍都有說，基本用法是：先從TThread派生一個自己的線程類（因為TThread

是一個抽象類，不能生成執行個體），然後是Override抽象方法：Execute（這就是線程函數，也就是線上程中執行的代碼

部分），如果需要用到可視VCL對象，還需要通過Synchronize過程進行。關于之方面的具體細節，這裡不再贅述，請

參考相關書籍。

本文接下來要讨論的是TThread類是如何對線程進行封裝的，也就是深入研究一下TThread類的實作。因為隻是真正地

了解了它，才更好地使用它。

下面是DELPHI7中TThread類的聲明（本文隻讨論在Windows平台下的實作，是以去掉了所有有關Linux平台部分的代碼

）：

TThread = class

private

    FHandle: THandle;

    FThreadID: THandle;

    FCreateSuspended: Boolean;

    FTerminated: Boolean;

    FSuspended: Boolean;

    FFreeOnTerminate: Boolean;

    FFinished: Boolean;

    FReturnValue: Integer;

    FOnTerminate: TNotifyEvent;

    FSynchronize: TSynchronizeRecord;

    FFatalException: TObject;

    procedure CallOnTerminate;

    class procedure Synchronize(ASyncRec: PSynchronizeRecord); overload;

    function GetPriority: TThreadPriority;

    procedure SetPriority(Value: TThreadPriority);

    procedure SetSuspended(Value: Boolean);

protected

    procedure CheckThreadError(ErrCode: Integer); overload;

    procedure CheckThreadError(Success: Boolean); overload;

    procedure DoTerminate; virtual;

    procedure Execute; virtual; abstract;

    procedure Synchronize(Method: TThreadMethod); overload;

    property ReturnValue: Integer read FReturnValue write FReturnValue;

    property Terminated: Boolean read FTerminated;

public

    constructor Create(CreateSuspended: Boolean);

    destructor Destroy; override;

    procedure AfterConstruction; override;

    procedure Resume;

    procedure Suspend;

    procedure Terminate;

    function WaitFor: LongWord;

    class procedure Synchronize(AThread: TThread; AMethod: TThreadMethod); overload;

    class procedure StaticSynchronize(AThread: TThread; AMethod: TThreadMethod);

    property FatalException: TObject read FFatalException;

    property FreeOnTerminate: Boolean read FFreeOnTerminate write FFreeOnTerminate;

    property Handle: THandle read FHandle;

    property Priority: TThreadPriority read GetPriority write SetPriority;

    property Suspended: Boolean read FSuspended write SetSuspended;

    property ThreadID: THandle read FThreadID;

    property OnTerminate: TNotifyEvent read FOnTerminate write FOnTerminate;

end;

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不能。或者按作業系統理論中的術語來說，這是一對“原語”操作。

以加一為例來說明二者實作細節上的不同：

一般來說，對記憶體資料加一的操作分解以後有三個步驟：

1、 從記憶體中讀出資料

2、 資料加一

3、 存入記憶體

現在假設在一個兩個線程的應用中用Inc進行加一操作可能出現的一種情況：

1、 線程A從記憶體中讀出資料（假設為3）

2、 線程B從記憶體中讀出資料（也是3）

3、 線程A對資料加一（現在是4）

4、 線程B對資料加一（現在也是4）

5、 線程A将資料存入記憶體（現在記憶體中的資料是4）

6、 線程B也将資料存入記憶體（現在記憶體中的資料還是4，但兩個線程都對它加了一，應該是5才對，是以這裡出現了

錯誤的結果）

而用InterlockIncrement過程則沒有這個問題，因為所謂“原語”是一種不可中斷的操作，即作業系統能保證在一個

“原語”執行完畢前不會進行線程切換。是以在上面那個例子中，隻有當線程A執行完将資料存入記憶體後，線程B才可

以開始從中取數并進行加一操作，這樣就保證了即使是在多線程情況下，結果也一定會是正确的。

前面那個例子也說明一種“線程通路沖突”的情況，這也就是為什麼線程之間需要“同步”（Synchronize），關于這

個，在後面說到同步時還會再詳細讨論。

說到同步，有一個題外話：加拿大滑鐵盧大學的教授李明曾就Synchronize一詞在“線程同步”中被譯作“同步”提出

過異議，個人認為他說的其實很有道理。在中文中“同步”的意思是“同時發生”，而“線程同步”目的就是避免這

種“同時發生”的事情。而在英文中，Synchronize的意思有兩個：一個是傳統意義上的同步（To occur at the same

time），另一個是“協調一緻”（To operate in unison）。在“線程同步”中的Synchronize一詞應該是指後面一種

意思，即“保證多個線程在通路同一資料時，保持協調一緻，避免出錯”。不過像這樣譯得不準的詞在IT業還有很多

，既然已經是約定俗成了，本文也将繼續沿用，隻是在這裡說明一下，因為軟體開發是一項細緻的工作，該弄清楚的

，絕不能含糊。

扯遠了，回到TThread的構造函數上，接下來最重要就是這句了：

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

這裡就用到了前面說到的Delphi RTL函數BeginThread，它有很多參數，關鍵的是第三、四兩個參數。第三個參數就是

前面說到的線程函數，即線上程中執行的代碼部分。第四個參數則是傳遞給線程函數的參數，在這裡就是建立的線程

對象（即Self）。其它的參數中，第五個是用于設定線程在建立後即挂起，不立即執行（啟動線程的工作是在

AfterConstruction中根據CreateSuspended标志來決定的），第六個是傳回線程ID。

現在來看TThread的核心：線程函數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中最重要的部分，因為這段代碼是真正線上程中執行的代碼。下面對代碼作

逐行說明：

首先判斷線程類的Terminated标志，如果未被标志為終止，則調用線程類的Execute方法執行線程代碼，因為TThread

是抽象類，Execute方法是抽象方法，是以本質上是執行派生類中的Execute代碼。

是以說，Execute就是線程類中的線程函數，所有在Execute中的代碼都需要當作線程代碼來考慮，如防止通路沖突等。

如果Execute發生異常，則通過AcquireExceptionObject取得異常對象，并存入線程類的FFatalException成員中。

最後是線程結束前做的一些收尾工作。局部變量FreeThread記錄了線程類的FreeOnTerminated屬性的設定，然後将線

程傳回值設定為線程類的傳回值屬性的值。然後執行線程類的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;

也很簡單，就是設定一下一個全局Event：SyncEvent，關于Event的使用，本文将在後文詳述，而SyncEvent的用途将

在WaitFor過程中說明。

然後根據FreeThread中儲存的FreeOnTerminate設定決定是否釋放線程類，線上程類釋放時，還有一些些操作，詳見接

下來的析構函數實作。

最後調用EndThread結束線程，傳回線程傳回值。至此，線程完全結束。

說完構造函數，再來看析構函數：

destructor TThread.Destroy;

begin

  if (FThreadID <> 0) and not FFinished then  begin

      Terminate;

      if FCreateSuspended then

          Resume;

      WaitFor;

  end;

  if FHandle <> 0 then CloseHandle(FHandle);

  inherited Destroy;

  FFatalException.Free;

  RemoveThread;

end;

線上程對象被釋放前，首先要檢查線程是否還在執行中，如果線程還在執行中（線程ID不為0，并且線程結束标志未設

置），則調用Terminate過程結束線程。Terminate過程隻是簡單地設定線程類的Terminated标志，如下面的代碼：

procedure TThread.Terminate;

begin

    FTerminated := True;

end;

是以線程仍然必須繼續執行到正常結束後才行，而不是立即終止線程，這一點要注意。

在這裡說一點題外話：很多人都問過我，如何才能“立即”終止線程（當然是指用TThread建立的線程）。結果當然是

不行！終止線程的唯一辦法就是讓Execute方法執行完畢，是以一般來說，要讓你的線程能夠盡快終止，必須在

Execute方法中在較短的時間内不斷地檢查Terminated标志，以便能及時地退出。這是設計線程代碼的一個很重要的原

則！

當然如果你一定要能“立即”退出線程，那麼TThread類不是一個好的選擇，因為如果用API強制終止線程的話，最終

會導緻TThread線程對象不能被正确釋放，在對象析構時出現Access Violation。這種情況你隻能用API或RTL函數來創

建線程。

如果線程處于啟動挂起狀态，則将線程轉入運作狀态，然後調用WaitFor進行等待，其功能就是等待到線程結束後才繼

續向下執行。關于WaitFor的實作，将放到後面說明。

線程結束後，關閉線程Handle（正常線程建立的情況下Handle都是存在的），釋放作業系統建立的線程對象。

然後調用TObject.Destroy釋放本對象，并釋放已經捕獲的異常對象，最後調用RemoveThread減小程序的線程數。

其它關于Suspend/Resume及線程優先級設定等方面，不是本文的重點，不再贅述。下面要讨論的是本文的另兩個重點

：Synchronize和WaitFor。

但是在介紹這兩個函數之前，需要先介紹另外兩個線程同步技術：事件和臨界區。

事件（Event）與Delphi中的事件有所不同。從本質上說，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而挂起的線程，這就是它為什麼叫Event的原

因。所謂“事件”就是指“狀态的轉換”。通過Event可以線上程間傳遞這種“狀态轉換”資訊。

當然用一個受保護（見下面的臨界區介紹）的布爾變量也能實作類似的功能，隻要用一個循環檢查此布爾值的代碼來

代替WaitFor即可。從功能上說完全沒有問題，但實際使用中就會發現，這樣的等待會占用大量的CPU資源，降低系統

性能，影響到别的線程的執行速度，是以是不經濟的，有的時候甚至可能會有問題。是以不建議這樣用。

臨界區（CriticalSection）則是一項共享資料通路保護的技術。它其實也是相當于一個全局的布爾變量。但對它的操

作有所不同，它隻有兩個操作：Enter和Leave，同樣可以把它的兩個狀态當作True和False，分别表示現在是否處于臨

界區中。這兩個操作也是原語，是以它可以用于在多線程應用中保護共享資料，防止通路沖突。

用臨界區保護共享資料的方法很簡單：在每次要通路共享資料之前調用Enter設定進入臨界區标志，然後再操作資料，

最後調用Leave離開臨界區。它的保護原理是這樣的：當一個線程進入臨界區後，如果此時另一個線程也要通路這個數

據，則它會在調用Enter時，發現已經有線程進入臨界區，然後此線程就會被挂起，等待目前在臨界區的線程調用

Leave離開臨界區，當另一個線程完成操作，調用Leave離開後，此線程就會被喚醒，并設定臨界區标志，開始操作數

據，這樣就防止了通路沖突。

以前面那個InterlockedIncrement為例，我們用CriticalSection（Windows API）來實作它：

Var

InterlockedCrit : TRTLCriticalSection;

Procedure InterlockedIncrement( var aValue : Integer );

Begin

    EnterCriticalSection( InterlockedCrit );

    Inc( aValue );

    LeaveCriticalSection( InterlockedCrit );

End;

現在再來看前面那個例子：

1. 線程A進入臨界區（假設資料為3）

2. 線程B進入臨界區，因為A已經在臨界區中，是以B被挂起

3. 線程A對資料加一（現在是4）

4. 線程A離開臨界區，喚醒線程B（現在記憶體中的資料是4）

5. 線程B被喚醒，對資料加一（現在就是5了）

6. 線程B離開臨界區，現在的資料就是正确的了。

臨界區就是這樣保護共享資料的通路。

關于臨界區的使用，有一點要注意：即資料通路時的異常情況處理。因為如果在資料操作時發生異常，将導緻Leave操

作沒有被執行，結果将使本應被喚醒的線程未被喚醒，可能造成程式的沒有響應。是以一般來說，如下面這樣使用臨

界區才是正确的做法：

EnterCriticalSection

Try

// 操作臨界區資料

Finally

    LeaveCriticalSection

End;

最後要說明的是，Event和CriticalSection都是作業系統資源，使用前都需要建立，使用完後也同樣需要釋放。如

TThread類用到的一個全局Event：SyncEvent和全局CriticalSection：TheadLock，都是在

InitThreadSynchronization和DoneThreadSynchronization中進行建立和釋放的，而它們則是在Classes單元的

Initialization和Finalization中被調用的。

由于在TThread中都是用API來操作Event和CriticalSection的，是以前面都是以API為例，其實Delphi已經提供了對它

們的封裝，在SyncObjs單元中，分别是TEvent類和TCriticalSection類。用法也與前面用API的方法相差無幾。因為

TEvent的構造函數參數過多，為了簡單起見，Delphi還提供了一個用預設參數初始化的Event類：TSimpleEvent。

順便再介紹一下另一個用于線程同步的類：TMultiReadExclusiveWriteSynchronizer，它是在SysUtils單元中定義的

。據我所知，這是Delphi RTL中定義的最長的一個類名，還好它有一個短的别名：TMREWSync。至于它的用處，我想光

看名字就可以知道了，我也就不多說了。

有了前面對Event和CriticalSection的準備知識，可以正式開始讨論Synchronize和WaitFor了。

我們知道，Synchronize是通過将部分代碼放到主線程中執行來實作線程同步的，因為在一個程序中，隻有一個主線程

。先來看看Synchronize的實作：

procedure TThread.Synchronize(Method: TThreadMethod);

begin

    FSynchronize.FThread := Self;

    FSynchronize.FSynchronizeException := nil;

    FSynchronize.FMethod := Method;

    Synchronize(@FSynchronize);

end;

其中FSynchronize是一個記錄類型：

PSynchronizeRecord = ^TSynchronizeRecord;

TSynchronizeRecord = record

    FThread: TObject;

    FMethod: TThreadMethod;

    FSynchronizeException: TObject;

end;

用于進行線程和主線程之間進行資料交換，包括傳入線程類對象，同步方法及發生的異常。

在Synchronize中調用了它的一個重載版本，而且這個重載版本比較特别，它是一個“類方法”。所謂類方法，是一種

特殊的類成員方法，它的調用并不需要建立類執行個體，而是像構造函數那樣，通過類名調用。之是以會用類方法來實作

它，是因為為了可以線上程對象沒有建立時也能調用它。不過實際中是用它的另一個重載版本（也是類方法）和另一

個類方法StaticSynchronize。下面是這個Synchronize的代碼：

class procedure TThread.Synchronize(ASyncRec: PSynchronizeRecord);

var

    SyncProc: TSyncProc;

begin

    if GetCurrentThreadID = MainThreadID then

        ASyncRec.FMethod

    else begin

    SyncProc.Signal := CreateEvent(nil, True, False, nil);

    try

    EnterCriticalSection(ThreadLock);

    try

    if SyncList = nil then

        SyncList := TList.Create;

        SyncProc.SyncRec := ASyncRec;

        SyncList.Add(@SyncProc);

        SignalSyncEvent;

        if Assigned(WakeMainThread) then

            WakeMainThread(SyncProc.SyncRec.FThread);

        LeaveCriticalSection(ThreadLock);

        try

            WaitForSingleObject(SyncProc.Signal, INFINITE);

        finally

            EnterCriticalSection(ThreadLock);

        end;

        finally

            LeaveCriticalSection(ThreadLock);

        end;

        finally

            CloseHandle(SyncProc.Signal);

        end;

        if Assigned(ASyncRec.FSynchronizeException) then

            raise ASyncRec.FSynchronizeException;

    end;

end;

這段代碼略多一些，不過也不算太複雜。

首先是判斷目前線程是否是主線程，如果是，則簡單地執行同步方法後傳回。

如果不是主線程，則準備開始同步過程。

通過局部變量SyncProc記錄線程交換資料（參數）和一個Event Handle，其記錄結構如下：

TSyncProc = record

SyncRec: PSynchronizeRecord;

Signal: THandle;

end;

然後建立一個Event，接着進入臨界區（通過全局變量ThreadLock進行，因為同時隻能有一個線程進入Synchronize狀

态，是以可以用全局變量記錄），然後就是把這個記錄資料存入SyncList這個清單中（如果這個清單不存在的話，則

建立它）。可見ThreadLock這個臨界區就是為了保護對SyncList的通路，這一點在後面介紹CheckSynchronize時會再

次看到。

再接下就是調用SignalSyncEvent，其代碼在前面介紹TThread的構造函數時已經介紹過了，它的功能就是簡單地将

SyncEvent作一個Set的操作。關于這個SyncEvent的用途，将在後面介紹WaitFor時再詳述。

接下來就是最主要的部分了：調用WakeMainThread事件進行同步操作。WakeMainThread是一個TNotifyEvent類型的全

局事件。這裡之是以要用事件進行處理，是因為Synchronize方法本質上是通過消息，将需要同步的過程放到主線程中

執行，如果在一些沒有消息循環的應用中（如Console或DLL）是無法使用的，是以要使用這個事件進行處理。

而響應這個事件的是Application對象，下面兩個方法分别用于設定和清空WakeMainThread事件的響應（來自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;

而這個消息的響應也是在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的代碼。

在執行完WakeMainThread事件後，就退出臨界區，然後調用WaitForSingleObject開始等待在進入臨界區前建立的那個

Event。這個Event的功能是等待這個同步方法的執行結束，關于這點，在後面分析CheckSynchronize時會再說明。

注意在WaitForSingleObject之後又重新進入臨界區，但沒有做任何事就退出了，似乎沒有意義，但這是必須的！

因為臨界區的Enter和Leave必須嚴格的一一對應。那麼是否可以改成這樣呢：

if Assigned(WakeMainThread) then

    WakeMainThread(SyncProc.SyncRec.FThread);

    WaitForSingleObject(SyncProc.Signal, INFINITE);

    finally

        LeaveCriticalSection(ThreadLock);

end;

上面的代碼和原來的代碼最大的差別在于把WaitForSingleObject也納入臨界區的限制中了。看上去沒什麼影響，還使

代碼大大簡化了，但真的可以嗎？

事實上是不行！

因為我們知道，在Enter臨界區後，如果别的線程要再進入，則會被挂起。而WaitFor方法則會挂起目前線程，直到等

待别的線程SetEvent後才會被喚醒。如果改成上面那樣的代碼的話，如果那個SetEvent的線程也需要進入臨界區的話

，死鎖（Deadlock）就發生了（關于死鎖的理論，請自行參考作業系統原理方面的資料）。

死鎖是線程同步中最需要注意的方面之一！

最後釋放開始時建立的Event，如果被同步的方法傳回異常的話，還會在這裡再次抛出異常。

回到前面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;

     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

                                   SyncProc.SyncRec.FSynchronizeException := AcquireExceptionObject;

                              end;

                         finally

                              EnterCriticalSection(ThreadLock);

                         end;

                         SetEvent(SyncProc.signal);

                    end;

               end;

          finally

               LocalSyncList.Free;

          end;

     finally

          LeaveCriticalSection(ThreadLock);

     end;

end;

首先，這個方法必須在主線程中被調用（如前面通過消息傳遞到主線程），否則就抛出異常。

接下來調用ResetSyncEvent（它與前面SetSyncEvent對應的，之是以不考慮WaitForSyncEvent的情況，是因為隻有在

Linux版下才會調用帶參數的CheckSynchronize，Windows版下都是調用預設參數0的CheckSynchronize）。

現在可以看出SyncList的用途了：它是用于記錄所有未被執行的同步方法的。因為主線程隻有一個，而子線程可能有

很多個，當多個子線程同時調用同步方法時，主線程可能一時無法處理，是以需要一個清單來記錄它們。

在這裡用一個局部變量LocalSyncList來交換SyncList，這裡用的也是一個原語：InterlockedExchange。同樣，這裡

也是用臨界區将對SyncList的通路保護起來。

隻要LocalSyncList不為空，則通過一個循環來依次處理累積的所有同步方法調用。最後把處理完的LocalSyncList釋

放掉，退出臨界區。

再來看對同步方法的處理：首先是從清單中移出（取出并從清單中删除）第一個同步方法調用資料。然後退出臨界區

（原因當然也是為了防止死鎖）。

接着就是真正的調用同步方法了。

如果同步方法中出現異常，将被捕獲後存入同步方法資料記錄中。

重新進入臨界區後，調用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;

        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;

如果不是在主線程中執行WaitFor的話，很簡單，隻要調用WaitForSingleObject等待此線程的Handle為Signaled狀态

即可。

如果是在主線程中執行WaitFor則比較麻煩。首先要在Handle數組中增加一個SyncEvent，然後循環等待，直到線程結

束（即MsgWaitForMultipleObjects傳回WAIT_OBJECT_0，詳見MSDN中關于此API的說明）。

在循環等待中作如下處理：如果有消息發生，則通過PeekMessage取出此消息（但并不把它從消息循環中移除），然後

調用MsgWaitForMultipleObjects來等待線程Handle或SyncEvent出現Signaled狀态，同時監聽消息（QS_SENDMESSAGE

參數，詳見MSDN中關于此API的說明）。可以把此API當作一個可以同時等待多個Handle的WaitForSingleObject。如果

是SyncEvent被SetEvent（傳回WAIT_OBJECT_0 + 1），則調用CheckSynchronize處理同步方法。

為什麼在主線程中調用WaitFor必須用MsgWaitForMultipleObjects，而不能用WaitForSingleObject等待線程結束呢？

因為防止死鎖。由于線上程函數Execute中可能調用Synchronize處理同步方法，而同步方法是在主線程中執行的，如

果用WaitForSingleObject等待的話，則主線程在這裡被挂起，同步方法無法執行，導緻線程也被挂起，于是發生死鎖。

而改用WaitForMultipleObjects則沒有這個問題。首先，它的第三個參數為False，表示隻要線程Handle或SyncEvent

中隻要有一個Signaled即可使主線程被喚醒，至于加上QS_SENDMESSAGE是因為Synchronize是通過消息傳到主線程來的

，是以還要防止消息被阻塞。這樣，當線程中調用Synchronize時，主線程就會被喚醒并處理同步調用，在調用完成後

繼續進入挂起等待狀态，直到線程結束。

至此，對線程類TThread的分析可以告一個段落了，對前面的分析作一個總結：

1、 線程類的線程必須按正常的方式結束，即Execute執行結束，是以在其中的代碼中必須在适當的地方加入足夠多

    的對Terminated标志的判斷，并及時退出。如果必須要“立即”退出，則不能使用線程類，而要改用API或RTL函數。

2、 對可視VCL的通路要放在Synchronize中，通過消息傳遞到主線程中，由主線程處理。

3、 線程共享資料的通路應該用臨界區進行保護（當然用Synchronize也行）。

4、 線程通信可以采用Event進行（當然也可以用Suspend/Resume）。

5、 當在多線程應用中使用多種線程同步方式時，一定要小心防止出現死鎖。

6、 等待線程結束要用WaitFor方法。