delphi多線程[通俗易懂]

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;

ThreadFunc：線程函數，

BeginThread：線程啟動函數。

這三個函數的功能是基本相同的，它們都是將線程函數中的代碼放到一個獨立的線程中執行。線程函數與一般函數的最大不同在于，線程函數一開始執行，這三個線程啟動函數就返回了，主線程繼續向下執行，而線程函數在一個獨立的線程中執行，它要執行多久，什么時候返回，主線程是不管也不知道的。
正常情況下，線程函數返回后，線程就終止了。但也有其它方式：
//以下3個函數能主動終止線程，而使用TThread類則沒法在線程的執行過程中終止線程
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;//delphihelp中找不到
FFatalException: TObject;
procedure CallOnTerminate;//調用在OnTerminate編寫的代碼
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;//將會調用 CallOnTerminate
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);//BeginThread創建掛起線程，在AfterConstruction過程中才根據FCreateSuspended確定是否執行
if FHandle = 0 then
raise EThread.CreateResFmt(@SThreadCreateError, [SysErrorMessage(GetLastError)]);

end;

雖然這個構造函數沒有多少代碼，但卻可以算是最重要的一個成員，因為線程就是在這里被創建的。
在通過Inherited調用TObject.Create后，第一句就是調用一個過程：AddThread，其源碼如下：

procedure AddThread;
begin
InterlockedIncrement(ThreadCount); //此為kernel32內核函數的調用
end;

同樣有一個對應的RemoveThread：
procedure RemoveThread;
begin
InterlockedDecrement(ThreadCount);
end;

ThreadCount為全卻變量

它們的功能很簡單，就是通過增減一個全局變量來統計進程中的線程數。只是這里用于增減變量的并不是常用的Inc/Dec過程，而是用了InterlockedIncrement/InterlockedDecrement這一對過程，它們實現的功能完全一樣，都是對變量加一或減一。但它們有一個最大的區別，那就是InterlockedIncrement/InterlockedDecrement是線程安全的。即它們在多線程下能保證執行結果正確，而Inc/Dec不能?；蛘甙床僮飨到y理論中的術語來說，這是一對“原語”操作。
以加一為例來說明二者實現細節上的不同：
一般來說，對內存數據加一的操作分解以后有三個步驟：
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過程的參數約定只能用全局函數）。下面是它的代碼：

ThreadProc為全局函數

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;//標識FTerminated,表示線程已經終止運行
Thread.FFinished := True;//標識線程代碼已經執行完畢
SignalSyncEvent;
if FreeThread then Thread.Free;
EndThread(Result);//使用RTL函數終止線程
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);//SetEvent也是kernel32函數
end;
SyncEvent是全局變量

{ SyncEvent is an Event handle that is signaled every time a thread wishes to
synchronize with the main thread or is terminating. This handle us suitable
for use with WaitForMultipleObjects. When this object is signaled,
CheckSynchronize *must* be called in order to reset the event. Do not call
ResetEvent on this handle, or background threads may hang waiting for
Synchronize to return.
}

也很簡單，就是設置一下一個全局Event：SyncEvent，關于Event的使用，本文將在后文詳述，而SyncEvent的用途將在WaitFor過程中說明。

然后根據FreeThread中保存的FreeOnTerminate設置決定是否釋放線程類，在線程類釋放時，還有一些操作，詳見接下來的析構函數實現。

最后調用EndThread結束線程，返回線程返回值。

至此，線程完全結束。

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

destructor TThread.Destroy;

begin

if (FThreadID <> 0) and not FFinished then

begin

Terminate;
//只是簡單地設置線程類的Terminated標志

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（即全局SyncEvent）的狀態是否是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這個列表中（如果這個列表不存在的話，則創建它）?？梢奣hreadLock這個臨界區就是為了保護對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的說明）?？梢园汛薃PI當作一個可以同時等待多個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方法。

———————————————————————-MY GOD——————————————————————–

在Delphi中,多線程的應用是比較多的內容,同時由于現在CPU中多核的發展,開發多線程程序也顯得較為重要,對于多線程包含有幾種狀態(創建,運行,掛起,喚醒,銷毀)如不清晰的請自己查找相關的資料查看.本文本是在多線程中重點需要注意的幾個方面的問題進行說明

1.使用Synchronize方法 對VCL的訪問只能在主線程中進行,這意味著
所有需要與用戶打交道的代碼都只能在主線程的環境中執行.通過TThread類中提供的Synchronize方法,可以實現此要求.對于此類的說明較多,不重點說明 2.多線程的同步機制 對于多線程的同步機制是說明的重點,主要是說明對于多線程幾種同步的方式進行比較說明.在多線程中同步機制主要是采用Windows API函數提供的同步機制:臨界區(Critical Section),互斥對象(Mutex)技術和信號量(semaphore)技術.
(1)臨界區(只能用來同步單個進程中的線程) 臨界區技術是指源代碼不能有兩個線程同時執行的部分,實際上臨界區是一小段代碼,一次只允許一個線程執行這段代碼.在這段代碼中可以執行以前要求對某些共享數據進行排它的存取.使用起來最為簡單,但是它只能用來同步單個進程中的線程.臨界區一次只允許一個線程取得對一個數據區的存取權. 在使用臨界區之前,必須使用InitializeCriticalSection過程進行初始化.其聲明如下: procedure InitializeCriticalSection (var lpCriticalSection:TRTLCriticalSection);stdcall; 使用臨界區時可以使用EnterCriticalSection與LeaveCriticalSection來進行臨界資源的管理 (2)互斥對象(可以被用來同步多個進程間的數據訪問,如多程序訪問打印機) 它們可以被用來同步多個進程間的數據訪問.互斥的一般使用流程是,進程必須首先用CreateMutex函數創建互斥對象,然后利用WaitForSingleObject進入互斥環境,當用到同步的代碼執行完成后,用ReleaseMutex解除互斥關系,當所有線程訪問完后,調用CloseHandle方法釋放互斥對象. 兩個進程之間必須都用同一互斥對象的句柄.互斥對象實際上串行訪問資源的全局對象.互斥對象不僅能在同一個程序下工作,而且可以在多個進程中同時工作.換句話說,它們既能夠在單個應用程序下使兩個或更多線程同步,也可以在不同的應用程序下進行多線程操作. 注:臨界區與互斥對象技術的區別如下: a.臨界區調用的是EnterCriticalSection和LeaveCriticalSection,而互斥對象調用的是WaitForSingleObject和ReleaseMutex b.互斥對象可以用于跨進程邊界同步線程 c.我們可以給互斥對象取字符串類型的名字,對于一個已知的互斥對象,我們可以通過引用互斥對象的名字來使用它 (3)信號量 操作系統并不對某個線程擁有信號量進行跟蹤.因此,一個線程等待某個信號量對象,觀察由另一個線程來釋放該信號量是可能的;另一個區別是,信號量有一個與之聯系的資源計數,一個互斥對象只允許一個線程獲得對它的訪問許可,而一個信號量卻允許多個線程同時獲得對它的訪問許可. 信號量創建時使用CreateSeaphore來創建,調用WaitForSingleObject來計數值加1,用ReleaseSemphore來釋放一個信號量,信號量的關閉采用CloseHandle進行處理 —————————————————————-OHH MY GOD——————————————————————- 一、臨界區

所謂臨界區，就是一次只能由一個線程來執行的一段代碼。如果把初始化數組的代碼放在臨界區內，另一個線程在第一個線程處理完之前是不會被執行的。

使用臨界區的步驟：

1、先聲明一個全局變量類型為TRTLCriticalSection；

2、在線程Create()前調用InitializeCriticalSection()過程來初始化，該函數定義是：

void WINAPI InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

類型lpCriticalSection即是Delphi封裝的TRTLCriticalSection。

3、在線程的需要放入臨界區的代碼前面使用EnterCriticalSection(lpCriticalSection)過程來開始建立臨界區。在代碼完成后用LeaveCriticalSection(lpCriticalSection)來標志臨界區的結束。

4、在線程執行完后用DeleteCriticalSection(lpCriticalSection)來清除臨界區。這個清除過程必須放在線程執行完后的地方，比如FormDesroy事件中。上面的例子中，若把該過程放在TMyThread.Create(False);后，會產生錯誤。

二、互斥：

互斥非常類似于臨界區，除了兩個關鍵的區別：首先，互斥可用于跨進程的線程同步。其次，互斥能被賦予一個字符串名字，并且通過引用此名字創建現有互斥對象的附加句柄。

提示臨界區與事件對象(比如互斥對象)的最大的區別是在性能上。
臨界區在沒有線程沖突時，要用10~15個時間片，而事件對象由于涉及到系統內核要用400~600個時間片。

使用互斥的步驟：

1、聲明一個類型為Thandle或Hwnd的全局變量,其實都是Cardinal類型。Hwnd是handle of window,主要用于窗口句柄；而Thandle則沒有限制。

2、線程Create()前用CreateMutex()來創建一個互斥量。該函數定義為：

HANDLE WINAPI CreateMutex(

LPSECURITY_ATTRIBUTES lpMutexAttributes,

BOOL bInitialOwner,

LPCTSTR lpName:Pchar);

LPSECURITY_ATTRIBUTES參數為一個指向TSecurityAttributtes記錄的指針。此參數設為nil，表示訪問控制列表默認的安全屬性。

bInitalOwner參數表示創建互斥對象的線程是否要成為此互斥對象的擁有者。當此參數為False時，表示互斥對象沒有擁有者。

lpName參數指定互斥對象的名稱。設為nil表示無命名，如果參數不是設為nil，函數會搜索是否有同名的互斥對象存在。如果有，函數就會返回同名互斥對象的句柄。否則，就新創建一個互斥對象并返回其句柄。

返回值是一handle。當錯誤發生時，返回null，此時用GetLastError函數可查看錯誤的信息。

利用CreateMutex()可以防止程序多個實例運行，如下例：

Program ABC;

Uses Forms,Windows,…;

{$R *.res}

Var

hMutex:Hwnd;

Begin

Application.Initialize;

hMutex:=CreateMutex(nil,False,Pchar(Application.Title));

if GetLastError<>ERROR_ALREADY_EXISTS then

begin

//項目要運行的咚咚

end;

ReleaseMutex(hMutex);

Application.Run;

End;

在本節的例程中，我們只是要防止線程進入同步代碼區域中，所以lpName參數設置為nil。

3、在同步代碼前用WaitForSingleObject()函數。該函數使得線程取得互斥對象（同步代碼）的擁有權。該函數定義為：

DWORD WINAPI WaitForSingleObject(

HANDLE hHandle,

DWORD dwMilliseconds);

這個函數可以使當前線程在dwMilliseconds指定的時間內睡眠，直到hHandle參數指定的對象進入發信號狀態為止。一個互斥對象不再被線程擁有時，它就進入發信號狀態。當一個進程要終止時，它就進入發信號狀態。dwMilliseconds參數可以設為0，這意味著只檢查hHandle參數指定的對象是否處于發信號狀態，而后立即返回。dwMilliseconds參數設為INFINITE，表示如果信號不出現將一直等下去。

這個函數的返回值含義：

WAIT_ABANDONED 指定的對象是互斥對象，并且擁有這個互斥對象的線程在沒有釋放此對象之前就已終止。此時就稱互斥對象被拋棄。這種情況下，這個互斥對象歸當前線程所有，并把它設為非發信號狀態

WAIT_OBJECT_0 指定的對象處于發信號狀態

WAIT_TIMEOUT 等待的時間已過，對象仍然是非發信號狀態

再次聲明，當一個互斥對象不再被一個線程所擁有,它就處于發信號狀態。此時首先調用WaitForSingleObject()函數的線程就成為該互斥對象的擁有者，此互斥對象設為不發信號狀態。當線程調用ReleaseMutex()函數并傳遞一個互斥對象的句柄作為參數時，這種擁有關系就被解除，互斥對象重新進入發信號狀態。

注意除WaitForSingleObject()函數外，你還可以使用WaitForMultipleObject()和MsgWaitForMultipleObject()函數，它們可以等待幾個對象變為發信號狀態。這兩個函數的詳細情況請看Win32 API聯機文檔。

4、在同步代碼結束后，使用ReleaseMutex(THandle)函數來標志。該函數只是用來解除線程與互斥對象的擁有關系，并不釋放互斥對象的句柄。

5、調用CloseHandle(THandle)來關閉互斥對象。請注意例程中該函數的使用位置。

三、還有一種用信號量對象來管理線程同步的，它是在互斥的基礎上建立的，但信號量增加了資源計數的功能，預定數目的線程允許同時進入要同步的代碼。有點復雜，想不到在哪可以用，現在就不研究論了。

unit Tst_Thread3U;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,Dialogs, StdCtrls;

type

TForm1 = class(TForm)

Button1: TButton;

Memo1: TMemo;

Button2: TButton;

Button3: TButton;

procedure Button1Click(Sender: TObject);

procedure Button2Click(Sender: TObject);

procedure Button3Click(Sender: TObject);

private

procedure ThreadsDone(Sender: TObject);

end;

TMyThread=class(TThread)

protected

procedure Execute;override;

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

const

MaxSize=128;

var

NextNumber:Integer=0;

DoneFlags:Integer=0;

GlobalArry:array[1..MaxSize] of Integer;

Lock:byte; //1-不同步 2-臨界區 3-互斥

CS:TRTLCriticalSection; //臨界區

hMutex:THandle; //互斥

function GetNextNumber:Integer;

begin

Result:=NextNumber;

inc(NextNumber);

end;

procedure TMyThread.Execute;

var

i:Integer;

begin

FreeOnTerminate:=True; //終止后自動free

OnTerminate:=Form1.ThreadsDone;

if Lock<>3 then //非互斥情況

begin

if Lock=2 then EnterCriticalSection(CS); //建立臨界區

for i := 1 to MaxSize do

begin

GlobalArry[i]:=GetNextNumber;

Sleep(5);

end;

if Lock=2 then LeaveCriticalSection(CS);//離開臨界區

end else //——-互斥

begin

if WaitForSingleObject(hMutex,INFINITE)=WAIT_OBJECT_0 then

begin

for i := 1 to MaxSize do

begin

GlobalArry[i]:=GetNextNumber;

Sleep(5);

end;

end;

ReleaseMutex(hMutex); //釋放

end;

end;

procedure TForm1.ThreadsDone(Sender: TObject);

var

i:Integer;

begin

Inc(DoneFlags);

if DoneFlags=2 then

begin

for i := 1 to MaxSize do

Memo1.Lines.Add(inttostr(GlobalArry[i]));

if Lock=2 then DeleteCriticalSection(CS); //刪除臨界區

If Lock=3 then CloseHandle(hMutex); //關閉互斥

end;

end;

//非同步

procedure TForm1.Button1Click(Sender: TObject);

begin

Lock:=1;

TMyThread.Create(False);

TMyThread.Create(False);

end;

//臨界區

procedure TForm1.Button2Click(Sender: TObject);

begin

Lock:=2;

InitializeCriticalSection(CS); //初始化臨界區

TMyThread.Create(False);

TMyThread.Create(False);

end;

//互斥

procedure TForm1.Button3Click(Sender: TObject);

begin

Lock:=3; // 互斥

hMutex:=CreateMutex(0,False,nil);

TMyThread.Create(False);

TMyThread.Create(False);

end;

end.

—————————————————————-my god—————————————————————–

多核時代的到來，對于我們程序員來說要盡快的，盡可能多的使用多線程編程只有這樣，作的程序才會有高效率，這個思想一定要宣傳啊，不然多核時代了，還寫單線程的程序就太不夠檔次了。 delphi中多線程同步的一些方法 當有多個線程的時候，經常需要去同步這些線程以訪問同一個數據或資源。例如，假設有一個程序，其中一個線程用于把文件讀到內存，而另一個線程用于統計文件中的字符數。當然，在把整個文件調入內存之前，統計它的計數是沒有意義的。但是，由于每個操作都有自己的線程，操作系統會把兩個線程當作是互不相干的任務分別執行，這樣就可能在沒有把整個文件裝入內存時統計字數。為解決此問題，你必須使兩個線程同步工作。 存在一些線程同步地址的問題，Win32提供了許多線程同步的方式。在本節你將看到使用臨界區、 互斥、信號量和事件來解決線程同步的問題。 1. 臨界區 臨界區是一種最直接的線程同步方式。所謂臨界區，就是一次只能由一個線程來執行的一段代碼。如果把初始化數組的代碼放在臨界區內，另一個線程在第一個線程處理完之前是不會被執行的。 在使用臨界區之前，必須使用InitializeCriticalSection()過程來初始化它。 其聲明如下： procedure InitializeCriticalSection( var lpCriticalSection參數是一個TRTLCriticalSection類型的記錄，并且是變參。至于TRTLCriticalSection 是如何定義的，這并不重要，因為很少需要查看這個記錄中的具體內容。只需要在lpCriticalSection中傳遞未初始化的記錄，InitializeCriticalSection()過程就會填充這個記錄。 注意Microsoft故意隱瞞了TRTLCriticalSection的細節。因為，其內容在不同的硬件平臺上是不同的。在基于Intel的平臺上，TRTLCriticalSection包含一個計數器、一個指示當前線程句柄的域和一個系統事件的句柄。在Alpha平臺上，計數器被替換為一種Alpha-CPU 數據結構，稱為spinlock。在記錄被填充后，我們就可以開始創建臨界區了。這時我們需要用EnterCriticalSection()和LeaveCriticalSection()來封裝代碼塊。這兩個過程的聲明如下： procedure EnterCriticalSection( var lpCriticalSection:TRRLCriticalSection);stdcall; procedure LeaveCriticalSection( var 正如你所想的，參數lpCriticalSection就是由InitializeCriticalSection()填充的記錄。 當你不需要TRTLCriticalSection記錄時，應當調用DeleteCriticalSection()過程，下面是它的聲明： procedure DeleteCriticalSection( var 2. 互斥 互斥非常類似于臨界區，除了兩個關鍵的區別：首先，互斥可用于跨進程的線程同步。其次，互斥能被賦予一個字符串名字，并且通過引用此名字創建現有互斥對象的附加句柄。 提示臨界區與事件對象(比如互斥對象)的最大的區別是在性能上。臨界區在沒有線程沖突時，要用1 0 ~ 1 5個時間片，而事件對象由于涉及到系統內核要用400~600個時間片。 可以調用函數CreateMutex ( )來創建一個互斥量。下面是函數的聲明： function lpMutexAttributes參數為一個指向TSecurityAttributtes記錄的指針。此參數通常設為0，表示默認的安全屬性。bInitalOwner參數表示創建互斥對象的線程是否要成為此互斥對象的擁有者。當此參數為False時， 表示互斥對象沒有擁有者。 lpName參數指定互斥對象的名稱。設為nil表示無命名，如果參數不是設為nil，函數會搜索是否有同名的互斥對象存在。如果有，函數就會返回同名互斥對象的句柄。否則，就新創建一個互斥對象并返回其句柄。 當使用完互斥對象時，應當調用CloseHandle()來關閉它。 在程序中使用WaitForSingleObject()來防止其他線程進入同步區域的代碼。此函數聲明如下： function 這個函數可以使當前線程在dwMilliseconds指定的時間內睡眠，直到hHandle參數指定的對象進入發信號狀態為止。一個互斥對象不再被線程擁有時，它就進入發信號狀態。當一個進程要終止時，它就進入發信號狀態。dwMilliseconds參數可以設為0，這意味著只檢查hHandle參數指定的對象是否處于發信號狀態，而后立即返回。dwMilliseconds參數設為INFINITE，表示如果信號不出現將一直等下去。 這個函數的返回值如下 WaitFor SingleObject()函數使用的返回值 返回值 含義 WAIT_ABANDONED 指定的對象是互斥對象，并且擁有這個互斥對象的線程在沒有釋放此對象之前就已終止。此時就稱互斥對象被拋棄。這種情況下，這個互斥對象歸當前線程所有，并把它設為非發信號狀態 WAIT_OBJECT_0 指定的對象處于發信號狀態 WAIT_TIMEOUT等待的時間已過，對象仍然是非發信號狀態再次聲明，當一個互斥對象不再被一個線程所擁有,它就處于發信號狀態。此時首先調用WaitForSingleObject()函數的線程就成為該互斥對象的擁有者，此互斥對象設為不發信號狀態。當線程調用ReleaseMutex()函數并傳遞一個互斥對象的句柄作為參數時，這種擁有關系就被解除，互斥對象重新進入發信號狀態。 注意除WaitForSingleObject()函數外，你還可以使用WaitForMultipleObject()和MsgWaitForMultipleObject()函數，它們可以等待幾個對象變為發信號狀態。這兩個函數的詳細情況請看Win32 API聯機文檔。 3. 信號量 另一種使線程同步的技術是使用信號量對象。它是在互斥的基礎上建立的，但信號量增加了資源計數的功能，預定數目的線程允許同時進入要同步的代碼?？梢杂肅reateSemaphore()來創建一個信號量對象，其聲明如下： function 和CreateMutex()函數一樣，CreateSemaphore()的第一個參數也是一個指向TSecurityAttribute s記錄的指針，此參數的缺省值可以設為nil。 lInitialCount參數用來指定一個信號量的初始計數值，這個值必須在0和lMaximumCount之間。此參數大于0，就表示信號量處于發信號狀態。當調用WaitForSingleObject()函數(或其他函數)時，此計數值就減1。當調用ReleaseSemaphore()時，此計數值加1。 參數lMaximumCount指定計數值的最大值。如果這個信號量代表某種資源，那么這個值代表可用資源總數。 參數lpName用于給出信號量對象的名稱，它類似于CreateMutex()函數的lpName參數。 —————————————————————————————————————————— ★★★關于線程同步： Synchronize()是在一個隱蔽的窗口里運行，如果在這里你的任務很繁忙，你的主窗口會阻塞掉；Synchronize()只是將該線程的代碼放到主線程中運行，并非線程同步。 臨界區是一個進程里的所有線程同步的最好辦法，他不是系統級的，只是進程級的，也就是說他可能利用進程內的一些標志來保證該進程內的線程同步，據Richter說是一個記數循環；臨界區只能在同一進程內使用；臨界區只能無限期等待，不過2k增加了TryEnterCriticalSection函數實現0時間等待。 互斥則是保證多進程間的線程同步，他是利用系統內核對象來保證同步的。由于系統內核對象可以是有名字的，因此多個進程間可以利用這個有名字的內核對象保證系統資源的線程安全性?；コ饬渴荳in32 內核對象，由操作系統負責管理；互斥量可以使用WaitForSingleObject實現無限等待，0時間等待和任意時間等待。 1. 臨界區 臨界區是一種最直接的線程同步方式。所謂臨界區，就是一次只能由一個線程來執行的一段代碼。如果把初始化數組的代碼放在臨界區內，另一個線程在第一個線程處理完之前是不會被執行的。在使用臨界區之前，必須使用InitializeCriticalSection()過程來初始化它。 在第一個線程調用了EnterCriticalSection()之后，所有別的線程就不能再進入代碼塊。下一個線程要等第一個線程調用LeaveCriticalSection()后才能被喚醒。 2. 互斥 互斥非常類似于臨界區，除了兩個關鍵的區別：首先，互斥可用于跨進程的線程同步。其次，互斥能被賦予一個字符串名字，并且通過引用此名字創建現有互斥對象的附加句柄。 提示：臨界區與事件對象(比如互斥對象)的最大的區別是在性能上。臨界區在沒有線程沖突時，要用10 ~ 15個時間片，而事件對象由于涉及到系統內核要用400~600個時間片。 當一個互斥對象不再被一個線程所擁有,它就處于發信號狀態。此時首先調用WaitForSingleObject()函數的線程就成為該互斥對象的擁有者，此互斥對象設為不發信號狀態。當線程調用ReleaseMutex()函數并傳遞一個互斥對象的句柄作為參數時，這種擁有關系就被解除，互斥對象重新進入發信號狀態。 可以調用函數CreateMutex()來創建一個互斥量。當使用完互斥對象時，應當調用CloseHandle()來關閉它。 3. 信號量 另一種使線程同步的技術是使用信號量對象。它是在互斥的基礎上建立的，但信號量增加了資源計數的功能，預定數目的線程允許同時進入要同步的代碼?？梢杂肅reateSemaphore()來創建一個信號量對象， 因為只允許一個線程進入要同步的代碼，所以信號量的最大計數值(lMaximumCount)要設為1。ReleaseSemaphore()函數將使信號量對象的計數加1； 記住，最后一定要調用CloseHandle()函數來釋放由CreateSemaphore()創建的信號量對象的句柄。 ★★★WaitForSingleObject函數的返值： WAIT_ABANDONED指定的對象是互斥對象，并且擁有這個互斥對象的線程在沒有釋放此對象之前就已終止。此時就稱互斥對象被拋棄。這種情況下，這個互斥對象歸當前線程所有，并把它設為非發信號狀態； WAIT_OBJECT_0 指定的對象處于發信號狀態； WAIT_TIMEOUT等待的時間已過，對象仍然是非發信號狀態； —————————————————————————————————————————————— VCL支持三種技術來達到這個目的： （2） 使用critical區 如果對象沒有提高內置的鎖定功能，需要使用critical區，Critical區在同一個時間只也許一個線程進入。為了使用Critical區，產生一個TCriticalSection全局的實例。TcriticalSection有兩個方法，Acquire(阻止其他線程執行該區域)和Release(取消阻止) 　　每個Critical區是與你想要保護的全局內存相關聯。每個訪問全局內存的線程必須首先使用Acquire來保證沒有其他線程使用它。完成以后，線程調用Release方法，讓其他線程也可以通過調用Acquire來使用這塊全局內存。 　　警告：Critical區只有在所有的線程都使用它來訪問全局內存，如果有線程直接調用內存，而不通過Acquire，會造成同時訪問的問題。例如：LockXY是一個全局的Critical區變量。任何一個訪問全局X, Y的變量的線程，在訪問前，都必須使用Acquire LockXY .Acquire; { lock out other threads } try Y := sin(X); finally LockXY .Release; end 臨界區主要是為實現線程之間同步的，但是使用的時候注意，一定要在用此臨界對象同步的線程之外建立該對象（一般在主線程中建立臨界對象）。 ———————————————————————————————————————————————— 線程同步使用臨界區，進程同步使用互斥對象。 Delphi中封裝了臨界對象。對象名為TCriticalSection，使用的時候只要在主線程當中建立這個臨界對象（注意一定要在需要同步的線程之外建立這個對象）。具體同步的時候使用Lock和Unlock即可。 而進程間同步建立互斥對象，則只需要建立一個互斥對象CreateMutex. 需要同步的時候只需要WaitForSingleObject(mutexhandle, INFINITE) unlock的時候只需要ReleaseMutex(mutexhandle);即可。 有很多方法, 信號燈, 臨界區, 互斥對象,此外, windows下還可以用全局原子,共享內存等等. 在windows體系中, 讀寫一個8位整數時原子的, 你可以依靠這一點完成互斥的方法. 對于能夠產生全局名稱的方法能夠可以在進程間同步上(如互斥對象), 也可以用在線程間同步上;不能夠產生全局名稱的方法(如臨界區)只能用在線程間同步上.