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方法。