轉貼于 華夏黑客同盟 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方法，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/323.html
標籤：Delphi