版塊導航: 正在加載中...

登錄注冊

應《網絡安全法》要求，自2017年10月1日起，未進行實名認證將不得使用互聯網跟帖服務。為保障您的帳號能夠正常使用，請盡快對帳號進行手機號驗證，感謝您的理解與支持！

24小時熱門版塊排行榜

北京石油化工學院2026年研究生招生接收調劑公告

返回列表

當前只顯示滿足指定條件的回帖，點擊這里查看本話題的所有回帖

zyj8119

兌換貴賓

應助: 65 (初中生)
貴賓: 0.003
金幣: 915.1
散金: 1440
紅花: 35
帖子: 2936
在線: 1329.4小時
蟲號: 664177
注冊: 2008-11-29
性別: GG
專業(yè): 理論和計算化學

[交流] 【轉帖】Delphi中的線程類已有1人參與

Delphi中的線程類--之（1）
Delphi中的線程類--之（1） Raptor（原作）

關鍵字    Thread Event CriticalSection Synchronize

Delphi中的線程類

猛禽[Mental Studio]

http://mental.mentsu.com

（之一）

Delphi中有一個線程類TThread是用來實現多線程編程的，這個絕大多數Delphi書藉都有說到，但基本上都是對TThread類的幾個成員作一簡單介紹，再說明一下Execute的實現和Synchronize的用法就完了。然而這并不是多線程編程的全部，我寫此文的目的在于對此作一個補充。

線程本質上是進程中一段并發(fā)運行的代碼。一個進程至少有一個線程，即所謂的主線程。同時還可以有多個子線程。當一個進程中用到超過一個線程時，就是所謂的“多線程”。

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

如果用Windows API來創(chuàng)建線程的話，是通過一個叫做CreateThread的API函數來實現的，它的定義為：

HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);

其各參數如它們的名稱所說，分別是：線程屬性（用于在NT下進行線程的安全屬性設置，在9X下無效），堆棧大小，起始地址，參數，創(chuàng)建標志（用于設置線程創(chuàng)建時的狀態(tài)），線程ID，最后返回線程Handle。其中的起始地址就是線程函數的入口，直至線程函數結束，線程也就結束了。
整個線程的執(zhí)行過程如下圖：
此主題相關圖片如下：

因為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;

這三個函數的功能是基本相同的，它們都是將線程函數中的代碼放到一個獨立的線程中執(zhí)行。線程函數與一般函數的最大不同在于，線程函數一啟動，這三個線程啟動函數就返回了，主線程繼續(xù)向下執(zhí)行，而線程函數在一個獨立的線程中執(zhí)行，它要執(zhí)行多久，什么時候返回，主線程是不管也不知道的。

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

Windows API：

VOID ExitThread( DWORD dwExitCode );
C Runtime Library：

void _endthread(void);

Delphi Runtime Library：

procedure EndThread(ExitCode: Integer);

為了記錄一些必要的線程數據（狀態(tài)/屬性等），OS會為線程創(chuàng)建一個內部Object，如在Windows中那個Handle便是這個內部Object的Handle，所以在線程結束的時候還應該釋放這個Object。



雖然說用API或RTL(Runtime Library)已經可以很方便地進行多線程編程了，但是還是需要進行較多的細節(jié)處理，為此Delphi在Classes單元中對線程作了一個較好的封裝，這就是VCL的線程類：TThread

使用這個類也很簡單，大多數的Delphi書籍都有說，基本用法是：先從TThread派生一個自己的線程類（因為TThread是一個抽象類，不能生成實例），然后是Override抽象方法：Execute（這就是線程函數，也就是在線程中執(zhí)行的代碼部分），如果需要用到可視VCL對象，還需要通過Synchronize過程進行。關于之方面的具體細節(jié)，這里不再贅述，請參考相關書籍。

本文接下來要討論的是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作詳細分析。

（待續(xù)）


Delphi中的線程類--之（2）
Delphi中的線程類--之（2） Raptor（原作）

關鍵字    Thread Event CriticalSection Synchronize

Delphi中的線程類

猛禽[Mental Studio]

http://mental.mentsu.com

回復此樓

» 猜你喜歡

» 本主題相關價值貼推薦，對您同樣有幫助:

好好學習，天天向上。

1樓 2010-12-02 15:50:37

已閱回復此樓關注TA 給TA發(fā)消息送TA紅花 TA的回帖

zyj8119

實習版主

應助: 65 (初中生)
貴賓: 0.003
金幣: 915.1
散金: 1440
紅花: 35
帖子: 2936
在線: 1329.4小時
蟲號: 664177
注冊: 2008-11-29
性別: GG
專業(yè): 理論和計算化學

引用回帖:

Originally posted by zyj8119 at 2010-12-02 15:51:28:

之二

首先就是構造函數：

constructor TThread.Create(CreateSuspended: Boolean);
begin
  inherited Create;
  AddThread;
  FSuspended := CreateSuspended;
  FCreateSuspended := Creat ...

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

Var
  InterlockedCrit : TRTLCriticalSection;

Procedure InterlockedIncrement( var aValue : Integer );
Begin
  EnterCriticalSection( InterlockedCrit );
  Inc( aValue );
  LeaveCriticalSection( InterlockedCrit );
End;

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

1.       線程A進入臨界區(qū)（假設數據為3）
2.       線程B進入臨界區(qū)，因為A已經在臨界區(qū)中，所以B被掛起
3.       線程A對數據加一（現在是4）
4.       線程A離開臨界區(qū)，喚醒線程B（現在內存中的數據是4）
5.       線程B被喚醒，對數據加一（現在就是5了）
6.       線程B離開臨界區(qū)，現在的數據就是正確的了。

臨界區(qū)就是這樣保護共享數據的訪問。

關于臨界區(qū)的使用，有一點要注意：即數據訪問時的異常情況處理。因為如果在數據操作時發(fā)生異常，將導致Leave操作沒有被執(zhí)行，結果將使本應被喚醒的線程未被喚醒，可能造成程序的沒有響應。所以一般來說，如下面這樣使用臨界區(qū)才是正確的做法：

EnterCriticalSection

Try

//  操作臨界區(qū)數據

Finally
  LeaveCriticalSection
End;



最后要說明的是，Event和CriticalSection都是操作系統資源，使用前都需要創(chuàng)建，使用完后也同樣需要釋放。如TThread類用到的一個全局Event：SyncEvent和全局CriticalSection：TheadLock，都是在InitThreadSynchronization和DoneThreadSynchronization中進行創(chuàng)建和釋放的，而它們則是在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是通過將部分代碼放到主線程中執(zhí)行來實現線程同步的，因為在一個進程中，只有一個主線程。先來看看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;

用于進行線程和主線程之間進行數據交換，包括傳入線程類對象，同步方法及發(fā)生的異常。

在Synchronize中調用了它的一個重載版本，而且這個重載版本比較特別，它是一個“類方法”。所謂類方法，是一種特殊的類成員方法，它的調用并不需要創(chuàng)建類實例，而是像構造函數那樣，通過類名調用。之所以會用類方法來實現它，是因為為了可以在線程對象沒有創(chuàng)建時也能調用它。不過實際中是用它的另一個重載版本（也是類方法）和另一個類方法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;

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

首先是判斷當前線程是否是主線程，如果是，則簡單地執(zhí)行同步方法后返回。

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

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

  TSyncProc = record
SyncRec: PSynchronizeRecord;
Signal: THandle;
  end;

然后創(chuàng)建一個Event，接著進入臨界區(qū)（通過全局變量ThreadLock進行，因為同時只能有一個線程進入Synchronize狀態(tài)，所以可以用全局變量記錄），然后就是把這個記錄數據存入SyncList這個列表中（如果這個列表不存在的話，則創(chuàng)建它）�？梢奣hreadLock這個臨界區(qū)就是為了保護對SyncList的訪問，這一點在后面介紹CheckSynchronize時會再次看到。

再接下就是調用SignalSyncEvent，其代碼在前面介紹TThread的構造函數時已經介紹過了，它的功能就是簡單地將SyncEvent作一個Set的操作。關于這個SyncEvent的用途，將在后面介紹WaitFor時再詳述。

接下來就是最主要的部分了：調用WakeMainThread事件進行同步操作。WakeMainThread是一個TNotifyEvent類型的全局事件。這里之所以要用事件進行處理，是因為Synchronize方法本質上是通過消息，將需要同步的過程放到主線程中執(zhí)行，如果在一些沒有消息循環(huán)的應用中（如Console或DLL）是無法使用的，所以要使用這個事件進行處理。

而響應這個事件的是Application對象，下面兩個方法分別用于設置和清空WakeMainThread事件的響應（來自Forms單元）：

procedure TApplication.HookSynchronizeWakeup;
begin
  Classes.WakeMainThread := WakeMainThread;
end;

procedure TApplication.UnhookSynchronizeWakeup;
begin
  Classes.WakeMainThread := nil;
end;

上面兩個方法分別是在TApplication類的構造函數和析構函數中被調用。

這就是在Application對象中WakeMainThread事件響應的代碼，消息就是在這里被發(fā)出的，它利用了一個空消息來實現：

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功能的部分就好，現在繼續(xù)分析Synchronize的代碼。

在執(zhí)行完WakeMainThread事件后，就退出臨界區(qū)，然后調用WaitForSingleObject開始等待在進入臨界區(qū)前創(chuàng)建的那個Event。這個Event的功能是等待這個同步方法的執(zhí)行結束，關于這點，在后面分析CheckSynchronize時會再說明。

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

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

      if Assigned(WakeMainThread) then
      WakeMainThread(SyncProc.SyncRec.FThread);
      WaitForSingleObject(SyncProc.Signal, INFINITE);
   finally
      LeaveCriticalSection(ThreadLock);
   end;

上面的代碼和原來的代碼最大的區(qū)別在于把WaitForSingleObject也納入臨界區(qū)的限制中了�？瓷先]什么影響，還使代碼大大簡化了，但真的可以嗎？

事實上是不行！

因為我們知道，在Enter臨界區(qū)后，如果別的線程要再進入，則會被掛起。而WaitFor方法則會掛起當前線程，直到等待別的線程SetEvent后才會被喚醒。如果改成上面那樣的代碼的話，如果那個SetEvent的線程也需要進入臨界區(qū)的話，死鎖（Deadlock）就發(fā)生了（關于死鎖的理論，請自行參考操作系統原理方面的資料）。

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

最后釋放開始時創(chuàng)建的Event，如果被同步的方法返回異常的話，還會在這里再次拋出異常。

贊一下

回復此樓

好好學習，天天向上。

3樓2010-12-02 15:51:40

已閱回復此樓關注TA 給TA發(fā)消息送TA紅花 TA的回帖

查看全部 4 個回答

zyj8119

管理員

應助: 65 (初中生)
貴賓: 0.003
金幣: 915.1
散金: 1440
紅花: 35
帖子: 2936
在線: 1329.4小時
蟲號: 664177
注冊: 2008-11-29
性別: GG
專業(yè): 理論和計算化學

引用回帖:

Originally posted by zyj8119 at 2010-12-02 15:50:37:
Delphi中的線程類--之（1）
Delphi中的線程類--之（1） Raptor（原作）

關鍵字 Thread Event CriticalSection Synchronize

Delphi中的線程類

猛禽[Mental Studio]

[url]http:/ ...

之二

首先就是構造函數：

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;

雖然這個構造函數沒有多少代碼，但卻可以算是最重要的一個成員，因為線程就是在這里被創(chuàng)建的。

在通過Inherited調用TObject.Create后，第一句就是調用一個過程：AddThread，其源碼如下：

procedure AddThread;
begin
  InterlockedIncrement(ThreadCount);
end;

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

它們的功能很簡單，就是通過增減一個全局變量來統計進程中的線程數。只是這里用于增減變量的并不是常用的Inc/Dec過程，而是用了InterlockedIncrement/InterlockedDecrement這一對過程，它們實現的功能完全一樣，都是對變量加一或減一。但它們有一個最大的區(qū)別，那就是InterlockedIncrement/InterlockedDecrement是線程安全的。即它們在多線程下能保證執(zhí)行結果正確，而Inc/Dec不能。或者按操作系統理論中的術語來說，這是一對“原語”操作。

以加一為例來說明二者實現細節(jié)上的不同：

一般來說，對內存數據加一的操作分解以后有三個步驟：

1、  從內存中讀出數據
2、  數據加一
3、  存入內存

現在假設在一個兩個線程的應用中用Inc進行加一操作可能出現的一種情況：
1、  線程A從內存中讀出數據（假設為3）
2、  線程B從內存中讀出數據（也是3）
3、  線程A對數據加一（現在是4）
4、  線程B對數據加一（現在也是4）
5、  線程A將數據存入內存（現在內存中的數據是4）
6、  線程B也將數據存入內存（現在內存中的數據還是4，但兩個線程都對它加了一，應該是5才對，所以這里出現了錯誤的結果）

而用InterlockIncrement過程則沒有這個問題，因為所謂“原語”是一種不可中斷的操作，即操作系統能保證在一個“原語”執(zhí)行完畢前不會進行線程切換。所以在上面那個例子中，只有當線程A執(zhí)行完將數據存入內存后，線程B才可以開始從中取數并進行加一操作，這樣就保證了即使是在多線程情況下，結果也一定會是正確的。

前面那個例子也說明一種“線程訪問沖突”的情況，這也就是為什么線程之間需要“同步”（Synchronize），關于這個，在后面說到同步時還會再詳細討論。

說到同步，有一個題外話：加拿大滑鐵盧大學的教授李明曾就Synchronize一詞在“線程同步”中被譯作“同步”提出過異議，個人認為他說的其實很有道理。在中文中“同步”的意思是“同時發(fā)生”，而“線程同步”目的就是避免這種“同時發(fā)生”的事情。而在英文中，Synchronize的意思有兩個：一個是傳統意義上的同步（To occur at the same time），另一個是“協調一致”（To operate in unison）。在“線程同步”中的Synchronize一詞應該是指后面一種意思，即“保證多個線程在訪問同一數據時，保持協調一致，避免出錯”。不過像這樣譯得不準的詞在IT業(yè)還有很多，既然已經是約定俗成了，本文也將繼續(xù)沿用，只是在這里說明一下，因為軟件開發(fā)是一項細致的工作，該弄清楚的，絕不能含糊。

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

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

這里就用到了前面說到的Delphi RTL函數BeginThread，它有很多參數，關鍵的是第三、四兩個參數。第三個參數就是前面說到的線程函數，即在線程中執(zhí)行的代碼部分。第四個參數則是傳遞給線程函數的參數，在這里就是創(chuàng)建的線程對象（即Self）。其它的參數中，第五個是用于設置線程在創(chuàng)建后即掛起，不立即執(zhí)行（啟動線程的工作是在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中最重要的部分，因為這段代碼是真正在線程中執(zhí)行的代碼。下面對代碼作逐行說明：

首先判斷線程類的Terminated標志，如果未被標志為終止，則調用線程類的Execute方法執(zhí)行線程代碼，因為TThread是抽象類，Execute方法是抽象方法，所以本質上是執(zhí)行派生類中的Execute代碼。

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

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

最后是線程結束前做的一些收尾工作。局部變量FreeThread記錄了線程類的FreeOnTerminated屬性的設置，然后將線程返回值設置為線程類的返回值屬性的值。然后執(zhí)行線程類的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中執(zhí)行的，所以本質上它并不是線程代碼，而是主線程代碼（具體見后面對Synchronize的分析）。

執(zhí)行完OnTerminate后，將線程類的FFinished標志設置為True。

接下來執(zhí)行SignalSyncEvent過程，其代碼如下：

procedure SignalSyncEvent;
begin
  SetEvent(SyncEvent);
end;

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

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

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

至此，線程完全結束。

（待續(xù)）

Delphi中的線程類--之（3）
Delphi中的線程類--之（3） Raptor（原作）

關鍵字    Thread Event CriticalSection Synchronize

Delphi中的線程類

猛禽[Mental Studio]

http://mental.mentsu.com

之三

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

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;

在線程對象被釋放前，首先要檢查線程是否還在執(zhí)行中，如果線程還在執(zhí)行中（線程ID不為0，并且線程結束標志未設置），則調用Terminate過程結束線程。Terminate過程只是簡單地設置線程類的Terminated標志，如下面的代碼：

procedure TThread.Terminate;
begin
  FTerminated := True;
end;

所以線程仍然必須繼續(xù)執(zhí)行到正常結束后才行，而不是立即終止線程，這一點要注意。

在這里說一點題外話：很多人都問過我，如何才能“立即”終止線程（當然是指用TThread創(chuàng)建的線程）。結果當然是不行！終止線程的唯一辦法就是讓Execute方法執(zhí)行完畢，所以一般來說，要讓你的線程能夠盡快終止，必須在Execute方法中在較短的時間內不斷地檢查Terminated標志，以便能及時地退出。這是設計線程代碼的一個很重要的原則！

當然如果你一定要能“立即”退出線程，那么TThread類不是一個好的選擇，因為如果用API強制終止線程的話，最終會導致TThread線程對象不能被正確釋放，在對象析構時出現Access Violation。這種情況你只能用API或RTL函數來創(chuàng)建線程。

如果線程處于啟動掛起狀態(tài)，則將線程轉入運行狀態(tài)，然后調用WaitFor進行等待，其功能就是等待到線程結束后才繼續(xù)向下執(zhí)行。關于WaitFor的實現，將放到后面說明。

線程結束后，關閉線程Handle（正常線程創(chuàng)建的情況下Handle都是存在的），釋放操作系統創(chuàng)建的線程對象。

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

其它關于Suspend/Resume及線程優(yōu)先級設置等方面，不是本文的重點，不再贅述。下面要討論的是本文的另兩個重點：Synchronize和WaitFor。

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

事件（Event）與Delphi中的事件有所不同。從本質上說，Event其實相當于一個全局的布爾變量。它有兩個賦值操作：Set和Reset，相當于把它設置為True或False。而檢查它的值是通過WaitFor操作進行。對應在Windows平臺上，是三個API函數：SetEvent、ResetEvent、WaitForSingleObject（實現WaitFor功能的API還有幾個，這是最簡單的一個）。

這三個都是原語，所以Event可以實現一般布爾變量不能實現的在多線程中的應用。Set和Reset的功能前面已經說過了，現在來說一下WaitFor的功能：

WaitFor的功能是檢查Event的狀態(tài)是否是Set狀態(tài)（相當于True），如果是則立即返回，如果不是，則等待它變?yōu)镾et狀態(tài)，在等待期間，調用WaitFor的線程處于掛起狀態(tài)。另外WaitFor有一個參數用于超時設置，如果此參數為0，則不等待，立即返回Event的狀態(tài)，如果是INFINITE則無限等待，直到Set狀態(tài)發(fā)生，若是一個有限的數值，則等待相應的毫秒數后返回Event的狀態(tài)。

當Event從Reset狀態(tài)向Set狀態(tài)轉換時，喚醒其它由于WaitFor這個Event而掛起的線程，這就是它為什么叫Event的原因。所謂“事件”就是指“狀態(tài)的轉換”。通過Event可以在線程間傳遞這種“狀態(tài)轉換”信息。

當然用一個受保護（見下面的臨界區(qū)介紹）的布爾變量也能實現類似的功能，只要用一個循環(huán)檢查此布爾值的代碼來代替WaitFor即可。從功能上說完全沒有問題，但實際使用中就會發(fā)現，這樣的等待會占用大量的CPU資源，降低系統性能，影響到別的線程的執(zhí)行速度，所以是不經濟的，有的時候甚至可能會有問題。所以不建議這樣用。

（待續(xù)）

Delphi中的線程類--之（4）
Delphi中的線程類--之（4） Raptor（原作）

關鍵字    Thread Event CriticalSection Synchronize

Delphi中的線程類

猛禽[Mental Studio]

http://mental.mentsu.com

之四

臨界區(qū)（CriticalSection）則是一項共享數據訪問保護的技術。它其實也是相當于一個全局的布爾變量。但對它的操作有所不同，它只有兩個操作：Enter和Leave，同樣可以把它的兩個狀態(tài)當作True和False，分別表示現在是否處于臨界區(qū)中。這兩個操作也是原語，所以它可以用于在多線程應用中保護共享數據，防止訪問沖突。

用臨界區(qū)保護共享數據的方法很簡單：在每次要訪問共享數據之前調用Enter設置進入臨界區(qū)標志，然后再操作數據，最后調用Leave離開臨界區(qū)。它的保護原理是這樣的：當一個線程進入臨界區(qū)后，如果此時另一個線程也要訪問這個數據，則它會在調用Enter時，發(fā)現已經有線程進入臨界區(qū)，然后此線程就會被掛起，等待當前在臨界區(qū)的線程調用Leave離開臨界區(qū)，當另一個線程完成操作，調用Leave離開后，此線程就會被喚醒，并設置臨界區(qū)標志，開始操作數據，這樣就防止了訪問沖突。

贊一下

回復此樓

好好學習，天天向上。

2樓2010-12-02 15:51:28

已閱回復此樓關注TA 給TA發(fā)消息送TA紅花 TA的回帖

zyj8119

管理員

應助: 65 (初中生)
貴賓: 0.003
金幣: 915.1
散金: 1440
紅花: 35
帖子: 2936
在線: 1329.4小時
蟲號: 664177
注冊: 2008-11-29
性別: GG
專業(yè): 理論和計算化學

引用回帖:

Originally posted by zyj8119 at 2010-12-02 15:51:40:

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

Var
InterlockedCrit : TRTLCriticalSection;

Procedure InterlockedIncrement( var aValue : Integer );
...

（待續(xù)）

Delphi中的線程類--之（5，大結局）
Delphi中的線程類--之（5，大結局） Raptor（原作）

關鍵字    Thread Event CriticalSection Synchronize

Delphi中的線程類

猛禽[Mental Studio]

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的用途了：它是用于記錄所有未被執(zhí)行的同步方法的。因為主線程只有一個，而子線程可能有很多個，當多個子線程同時調用同步方法時，主線程可能一時無法處理，所以需要一個列表來記錄它們。

在這里用一個局部變量LocalSyncList來交換SyncList，這里用的也是一個原語：InterlockedExchange。同樣，這里也是用臨界區(qū)將對SyncList的訪問保護起來。

只要LocalSyncList不為空，則通過一個循環(huán)來依次處理累積的所有同步方法調用。最后把處理完的LocalSyncList釋放掉，退出臨界區(qū)。

再來看對同步方法的處理：首先是從列表中移出（取出并從列表中刪除）第一個同步方法調用數據。然后退出臨界區(qū)（原因當然也是為了防止死鎖）。

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

如果同步方法中出現異常，將被捕獲后存入同步方法數據記錄中。

重新進入臨界區(qū)后，調用SetEvent通知調用線程，同步方法執(zhí)行完成了（詳見前面Synchronize中的WaitForSingleObject調用）。

至此，整個Synchronize的實現介紹完成。

最后來說一下WaitFor，它的功能就是等待線程執(zhí)行結束。其代碼如下：

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;

如果不是在主線程中執(zhí)行WaitFor的話，很簡單，只要調用WaitForSingleObject等待此線程的Handle為Signaled狀態(tài)即可。

如果是在主線程中執(zhí)行WaitFor則比較麻煩。首先要在Handle數組中增加一個SyncEvent，然后循環(huán)等待，直到線程結束（即MsgWaitForMultipleObjects返回WAIT_OBJECT_0，詳見MSDN中關于此API的說明）。

在循環(huán)等待中作如下處理：如果有消息發(fā)生，則通過PeekMessage取出此消息（但并不把它從消息循環(huán)中移除），然后調用MsgWaitForMultipleObjects來等待線程Handle或SyncEvent出現Signaled狀態(tài)，同時監(jiān)聽消息（QS_SENDMESSAGE參數，詳見MSDN中關于此API的說明）�？梢园汛薃PI當作一個可以同時等待多個Handle的WaitForSingleObject。如果是SyncEvent被SetEvent（返回WAIT_OBJECT_0 + 1），則調用CheckSynchronize處理同步方法。

為什么在主線程中調用WaitFor必須用MsgWaitForMultipleObjects，而不能用WaitForSingleObject等待線程結束呢？因為防止死鎖。由于在線程函數Execute中可能調用Synchronize處理同步方法，而同步方法是在主線程中執(zhí)行的，如果用WaitForSingleObject等待的話，則主線程在這里被掛起，同步方法無法執(zhí)行，導致線程也被掛起，于是發(fā)生死鎖。

而改用WaitForMultipleObjects則沒有這個問題。首先，它的第三個參數為False，表示只要線程Handle或SyncEvent中只要有一個Signaled即可使主線程被喚醒，至于加上QS_SENDMESSAGE是因為Synchronize是通過消息傳到主線程來的，所以還要防止消息被阻塞。這樣，當線程中調用Synchronize時，主線程就會被喚醒并處理同步調用，在調用完成后繼續(xù)進入掛起等待狀態(tài)，直到線程結束。

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

1、  線程類的線程必須按正常的方式結束，即Execute執(zhí)行結束，所以在其中的代碼中必須在適當的地方加入足夠多的對Terminated標志的判斷，并及時退出。如果必須要“立即”退出，則不能使用線程類，而要改用API或RTL函數。
2、  對可視VCL的訪問要放在Synchronize中，通過消息傳遞到主線程中，由主線程處理。
3、  線程共享數據的訪問應該用臨界區(qū)進行保護（當然用Synchronize也行）。
4、  線程通信可以采用Event進行（當然也可以用Suspend/Resume）。
5、  當在多線程應用中使用多種線程同步方式時，一定要小心防止出現死鎖。
6、  等待線程結束要用WaitFor方法。

贊一下

回復此樓

好好學習，天天向上。

4樓2010-12-02 15:52:01

已閱回復此樓關注TA 給TA發(fā)消息送TA紅花 TA的回帖

查看全部 4 個回答

最具人氣熱帖推薦 [查看全部]		作者	回/看	最后發(fā)表

[考研] 0856材料與化工調劑，339 +8	10213207 2026-03-31	8/400	2026-03-31 22:08 by lbsjt
[考研] 085600，321分求調劑 +7	大饞小子 2026-03-31	7/350	2026-03-31 18:02 by 無際的草原
[考研] 求化學調劑 +12	wulanna 2026-03-28	12/600	2026-03-31 16:38 by 690616278
[考研] 322求調劑 +3	熹僖XX 2026-03-31	3/150	2026-03-31 16:32 by 記事本2026
[考研] 293分求調劑，外語為俄語 +5	加一一九 2026-03-31	5/250	2026-03-31 09:39 by zhshch
[考研] 英一數一408，總分284，二戰(zhàn)真誠求調劑 +3	12.27 2026-03-30	5/250	2026-03-31 00:47 by 不吃芒果17
[考研] 085602化工求調劑（331分） +8	111@127 2026-03-30	8/400	2026-03-30 21:23 by 研究僧導導
[考研] 11408總分309，一志愿東南大學求調劑，不挑專業(yè) +5	天賦帶到THU 2026-03-29	6/300	2026-03-30 20:49 by dick_runner
[考研] 283求調劑（080500） +14	A child 2026-03-27	14/700	2026-03-30 12:06 by 探123
[考研] 311求調劑 +10	lin0039 2026-03-26	10/500	2026-03-30 10:26 by herarysara
[考研] 290求調劑 +3	dfffsar 2026-03-29	3/150	2026-03-29 22:38 by 毛毛毛阿莫2
[考研] 一志愿北京工業(yè)大學，324分求調劑 +6	零八# 2026-03-28	6/300	2026-03-29 21:20 by nanaliuyun
[考研] 求調劑 +4	QiMing7 2026-03-25	5/250	2026-03-29 21:10 by 唐沐兒
[考研] 332求92調劑 +8	蕉蕉123 2026-03-28	8/400	2026-03-29 10:46 by 周梓丹
[考研] 312，生物學求調劑 +3	小譯同學abc 2026-03-28	3/150	2026-03-28 15:32 by 落�？伤�
[考研] 304求調劑 +6	曼殊2266 2026-03-27	6/300	2026-03-28 14:10 by 唐沐兒
[考研] 283求調劑 +7	A child 2026-03-28	7/350	2026-03-28 12:05 by zllcz
[考研] 352分化工與材料 +5	海納百川Ly 2026-03-27	5/250	2026-03-28 03:39 by fmesaito
[考研] 348求調劑 +4	小懶蟲不懶了 2026-03-27	5/250	2026-03-27 12:47 by 果果媽咪
[考研] 081200-11408-276學碩求調劑 +3	崔wj 2026-03-26	3/150	2026-03-26 19:57 by nihaoar

亭亭五月天在线观看,亭亭五月天在线观看,国产最新av一区二区,国产 高清 中文字幕,99re热久久亚洲综合精品成人,熟妇 一区二区三区,一级做a爰片性色毛片武则天,美女的骚穴视频播放,国产美女午夜免费视频

24小時熱門版塊排行榜

zyj8119

[交流] 【轉帖】Delphi中的線程類 已有1人參與

» 猜你喜歡

» 本主題相關價值貼推薦，對您同樣有幫助:

zyj8119

zyj8119

zyj8119

亭亭五月天在线观看,亭亭五月天在线观看,国产最新av一区二区,国产高清中文字幕,99re热久久亚洲综合精品成人,熟妇一区二区三区,一级做a爰片性色毛片武则天,美女的骚穴视频播放,国产美女午夜免费视频

[交流] 【轉帖】Delphi中的線程類已有1人參與