http://www.kehui.org/aread.php?aid=20802
http://www.kehui.org/aread.php?aid=20798
Delphi中的線程類--之（1）
（ 之一）
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作詳細分析。
http://www.kehui.org/aread.php?aid=20799
Delphi中的線程類--之（2）
之二
首先就是構造函數：
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結束線程，返回線程返回值。
至此，線程完全結束。
http://www.kehui.org/aread.php?aid=20800
Delphi中的線程類--之（3）
之三
說完構造函數，再來看析構函數：
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資源，降低系統性能，影響到別的線程的執行速度，所以是不經濟的，有的時候甚至可
能會有問題。所以不建議這樣用。    Delphi中的線程類--之（4）
http://www.kehui.org/aread.php?aid=20801
之四
臨界區（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，如果被同步的方法返回異常的話，還會在這裏再次拋出異常。
Delphi中的線程類
http://mental.mentsu.com
回到前面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方法。