Delphi多線程詳解

時間 2019-11-19

原文原文鏈接

(整理自網絡)

Delphi多線程處理

1-1多線程的基本概念

WIN 98/NT/2000/XP 是個多任務操做系統，也就是：一個進程能夠劃分爲多個線程，每一個線程輪流佔用CPU 運行時間和資源，或者說，把CPU 時間劃成片，每一個片分給不一樣的線程，這樣，每一個線程輪流的「掛起」和「喚醒」，因爲時間片很小，給人的感受是同時運行的。html

多線程帶來以下好處：（本身閱讀）數據庫

1）避免瓶頸；編程

2）並行操做；數組

3）提升效率；安全

在多線程中，經過優先級管理，能夠使重要的程序優先操做，提升了任務管理的靈活性。服務器

另外一方面，在多CPU 系統中，能夠把不一樣的線程在不一樣的CPU 中執行，真正作到同時處理多任務（Win 98 只是模擬的，而Win/NT/2000是真正的多CPU同時操做）。網絡

多線程的兩個概念：session

1）進程：也稱任務，程序載入內存，並分配資源，稱爲「一個進程」。數據結構

注意：進程自己並不必定要正在執行。進程由如下幾部分組成：多線程

a>一個私有的地址空間，它是進程能夠使用的一組虛擬內存地址空間；

b>程序的相關代碼、數據源；

c>系統資源，好比操做系統同步對象等；

d>至少包含一個線程（主線程）；

2）線程：是程序的執行單位（線程自己並不包括程序代碼，真正擁有代碼的是進程），每一個進程至少包括一個線程，稱爲主線程，一個進程若是有多個線程，就能夠共享同一進程的資源，並能夠併發執行。

線程是進程的一個執行單元，是操做系統分配CPU 時間的基本實體，線程主要由以下兩部分組成：

a>數據結構；

b>CPU 寄存器和堆棧；

一個進程中的線程，能夠獨立運行，也能夠控制另外一個線程的運行。

請注意：

多線程不能濫用，書上提到了多線程的幾個缺點（自閱）。

1-2 Tthread 對象

雖然Windows 提供了比較多的多線程設計的API 函數，可是直接使用API 函數一方面極其不方便，並且使用不當還容易出錯。爲解決這個問題，Borland 公司率先推出了一種Tthread 對象，來解決多線程設計上的困難，簡化了多線程問題的處理。

應該注意，Tthread 對象是沒有實例的，它和界面的交流，主要依靠主窗體（主VCL線程），這和其餘對象使用上有些區別。

1、Tthread 對象的主要方法

構造線程：

constructor Create(CreateSuspended:boolean)

其中：CreateSuspended=true 構造但不喚醒

false 構造的同時即喚醒

也能夠用以下方法

inheried Create(CreateSuspended:boolean)

掛起線程：

suspend

（把線程掛起的次數加一）

喚醒線程：

resume

（注意：注意這個屬性是把線程掛起的次數減一，當次數爲0 時，即喚醒。也就是說，線程掛起多少次，喚醒也須要多少次。同時掛起的時候將保持線程的地址指針不變，因此線程掛起後再喚醒，將從掛起的地方開始運行）

析構（清除線程所佔用的內存）：

destroy

終止線程（後面會具體討論）:

Terminate

2、線程應用的簡單例子：

下面經過一個例子說明上述方法的應用。咱們知道，循環是獨佔性最強的運行方式之一，如今但願創建兩個線程對象，實現循環的並行運行。具體方法以下：

File---New---Thread Object

這就自動在主Form中創建了一個線程單元（在對話框裏寫上線程名字），默認的名字是Unit2。一樣方法創建第二個線程單元Unit3。

要注意的是：Unit2和Unit3中有一個給定的過程：

procedure Object.Execute;

begin

end;

其中的程序是線程喚醒後自動執行的程序，也能夠在裏面調用其餘自定義的過程和函數。這個過程的結束，意味着線程程序的結束。

爲了構造線程，在interface的Type區，定義一個構造過程：

type

Object = class(TThread) //自動給出的，也能夠直接改

private

protected

procedure Execute; override;

public

constructor create; //本身寫的

而且在implementation區域寫上：

constructor Object.create;

begin

inherited create(true);

end

其中Object 爲線程對象的名字。因此這麼寫，是但願在主Form中調用這個構造過程。

Create()的參數用True，代表構造出的線程爲掛起狀態。

注意一下，在同一個線程對象裏，若是兩次構造，將產生兩個獨立的線程，不但運行是獨立的，並且使用線程的局部變量也是獨立的。但這裏爲了簡化問題，仍是創建了兩個獨立的線程對象，並且兩個循環數

是不一樣的，在並行運算時容易判斷出是兩個不一樣的程序在運行。

假定咱們給兩個線程對象起的名字是：

mymath1

mymath2

這樣在Unit1，應該做以下聲明：

implementation

{$R *.DFM}

uses unit2,unit3;

var thread1:mymath1;

thread2:mymath2;

這樣在主線程，將能夠經過這兩個線程變量調用對應的線程方法。

在主線程區構造線程的方法是：

thread1:=mymath1.create;

thread2:=mymath2.create;

掛起：

thread1.suspend;

thread2.suspend;

喚醒：

thread1.resume;

thread2.resume;

析構：

thread1.destroy;

thread2.destroy;

這裏須要說明的是，因爲線程單元須要調用Form的Edit控件（對象），能夠採用兩種方法：

1）在線程單元定義一個TEdit對象，例如

edit4:Tedit;

在Execute過程內直接引用

但在Unit1中必定要在FormCreate過程裏做一個賦值：

procedure TForm1.FormCreate(Sender: TObject);

begin

thread1.edit4:=edit1;

end;

這樣，就把第一線程的edit4與Form上的edit1聯繫來。

2）在第二個線程中首先聲明調用Unti1，也就是要加上

Uses Unit1;

這樣就能夠在該線程單元直接調用主Form的控件了，好比在Unit3中能夠寫：

form1.edit2.text:=inttostr(i)

瞭解了這些基本規則，就能夠寫出比較複雜的多線程程序了。

還有一點要說明的，默認生成的線程單元，調用的單元只有一個：

Uses Classes;

這樣，每每不少函數和對象在線程單元裏不能使用，因此在必要時，應該根據須要User相應的單元，這個例程爲了簡單，把大部分經常使用的單元都拷過去了，這並非推薦的辦法，由於這樣一來會使程序的垃圾過

多，因此，通常要用什麼拷什麼。

3、經常使用的API 函數

在處理多線程問題的時候,也常常用到Windows提供的API 函數，須要說明的是，Tthread 對象內部封裝的方法，其實主要也是調用API 函數，可是，考慮更全面，更安全。而直接調用API 函數，每每會由於運用不當，出現一些不該有的錯誤。因此，我我的覺得，只要用Tthread 對象的方法能解決的，就不要直接調用API 函數，API 函數只應該在用在Tthread 對象方法解決不了的時候。

例如Tthread 對象方法內部調用API 函數的時候，通常使用推薦的默認值，但須要更精細的控制時，就能夠直接使用API 函數。

其實，Tthread 對象方法已經受到了大多數程序設計者的承認，好比，原來VB是不具有直接處理多線程的能力的，可是，如今VB.Net就宣稱，它具有了簡單處理多線程問題的能力，這就很說明問題。

下面簡單介紹幾種API 函數，爲了清晰方便，這裏着重在於說明，函數正確的描述能夠本身閱讀書上的例子和手冊：

構建線程：

CreateThread(參數1，--安全屬性（通常=Nil，默認安全屬性）

參數2，--線程堆棧尺寸（通常=0，與主線程相同長度，並且能夠根據須要自動變化）

參數3，--指向函數名指針，@函數名，這個參數十分重要，不正確將沒法調用成功。

參數4，--用戶須要向線程傳遞的參數，是一個指向結構的指針，不需傳遞參數時，爲Nil。

參數5）--傳入與線程有關的一些參數，例如：

CREATE_SUSPENDED 建立一個掛起的線程；

0 建立後當即激活。

書上有這個函數應用的十分清晰的例子，能夠本身閱讀。

通常並不推薦使用 CreateTheard函數，而推薦使用RTL 庫裏的System單元中定義的 BeginTheard函數，由於這除了能建立一個線程和一個入口函數之外，還增長了幾項保護措施，具體的請參閱書上的第10頁說明。

對應suspend（掛起）和resume（喚醒）的兩個API 函數爲：

Function SuspendThread(hThread:Thandle):DWORD;

Function ResumeThread（hThread:Thandle):DWORD;

其中，Thandle被要求控制線程的句柄，函數調用成功，返回掛起的次數，調用不成功。則返回0xFFFFFFFF。

4、線程的終止和退出：

1)自動退出：

一個線程從Execute()過程當中退出，即意味着線程的終止，此時將調用Windows的ExitThread()函數來清除線程所佔用的堆棧。

若是線程對象的 FreeOnTerminate 屬性設爲True，則線程對象將自動刪除，並釋放線程所佔用的資源。

這是消除線程對象最簡單的辦法。

2)受控退出：

利用線程對象的Terminate屬性，能夠由進程或者由其餘線程控制線程的退出。只須要簡單的調用該線程的Terminate方法，並設直線程對象的Terminate屬性爲True。

在線程中，應該不斷監視Terminate的值，一旦發現爲True，則退出，例如在Execute()過程當中能夠這樣寫：

While not Terminate do

begin

........

end;

3)退出的API 函數：

關於線程退出的API 函數聲明以下：code

Function TerminateThread(hThread:Thandle;dwExitCode:DWORD);

不過，這個函數會使代碼馬上終止，而無論程序中有沒有

try....finally

機制，可能會致使錯誤，不到萬不得已，最好不要使用。

4) 利用掛起線程的方法（suspend）

利用掛起線程的suspend方法，後面跟個Free，也能夠釋放線程，

例如：

thread1.suspend; //掛起

thread2.free; //釋放

書上有相應的例子。

5、線程的優先級：

在多線程的狀況下，通常要根據線程執行任務的重要性，給線程適當的優先級，通常若是量的線程同時申請CPU 時間，優先級高的線程優先。

在Windows下，給線程的優先級分爲30級，而Delphi中Tthread 對象相對簡單的把優先級分爲七級。也就是在Tthread中聲明瞭一個枚舉類型TTthreadPriority:

type

TTthreadPriority(tpidle,tpLowest,tpLower,tpNormal,

tpHight,tpHighest,tpTimecrital)

分別對應的是最低（系統空閒時有效，-15），較低（-2），低（-1），正常（普通0），高（1），較高（2），最高（15）。

其中tpidle和tpTimecrital有些特殊，具體狀況請閱讀書上有關內容。

設置優先級可以使用thread對象的priority屬性：

threadObject.priority:=Tthreadpriority(級別);

這裏給出了一個演示多線程優先級的實例：

1-3在數據庫中使用多線程

一）使用ADO模式

因爲Delphi 6.0的ADO 數據源控件內置了多線程能力，因此，在ADO模式下，使用多線程不須要作更多的工做。用兩個ADOTable控件，分別連到兩個數據庫，而且分別經過DataSource控件，與數據幫定控件聯繫就能夠了，這樣就能夠實現先後臺處理數據庫問題。

二）使用BDE模式和Tseeion對象

若是須要使用BDE 模式，那麼多線程使用數據庫，就要考慮Session的問題。在單線程時，每一個數據源的創建就自動生成一個Session，這是這個數據源私有的關於數據庫信息的文件。但多線程時，必須統一管理，因此在BDE 中專門提供了一個Tsession對象，它能夠同時管理不一樣的Databas數據源對象。

Databas數據源能夠接受來自不一樣數據平臺的數據庫。

數據庫1---databas(2)----table(Qurey)(3)---datasource

| |

|--------- Tsession(1)

| |

數據庫2---databas(2)----table(Qurey)(3)---datasource

方法：

1）Tsession

屬性：SessionName=名（自起）

Active=true （激活）

2）Database（能夠有多個）

屬性：SessionName=Tsession名

Dataname=名（自起，做爲Table的標識）

AliasName=數據庫別名

Connected=True （激活）

3）Table或Qurey

屬性：SessionName=Tsession名（不要用默認值）

DatabaseName=若是前面起了名，這裏就會出現Database

的名字。

Tablename=表名

Active=true （激活）

之後好比加入Datasoucre和其餘同樣，這樣就能夠構造兩個先後臺處理的數據庫管理系統了。

2.多線程的同步機制

同步機制，其實是事件驅動機制，意思是讓線程平時處於「休眠」狀態，除非發生某個事件才觸發。

例如一個拷貝文件，拷貝線程完成一個程序塊後，再喚醒進程條線程作一個格的填充。

研究多線程的同步機制的必要性在於，多線程同步工做時，若是同時調用相同的資源，就可能會出現問題，通常讀出是不會有問題的，可是，若是寫入（全局變量、數據庫），就會發生衝突，甚至產生死

鎖和競爭問題。

1、使用Synchronize方法

這個方法用於訪問VCL 主線程所管理的資源，其方法的應用是：

第一步：把訪問主窗口（或主窗口控件資源）的代碼放到線程的一個方法中；

第二步：是在線程對象的Execute方法中，經過Synchronize方法使用該方法。

實例：

procedure Theater.Execute;

begin

Synchronize(update);

end;

procedure Theater.update;

begin

.........

end;

這裏經過 Synchronize使線程方法update同步。

2、使用VCL類的Look方法

在Delphi的IDE提供的構件中，有一些對象內部提供了線程的同步機制，工做線程能夠直接使用這些控件，好比：Tfont，Tpen，TBitmap，TMetafile，Ticon等。另外，一個很重要的控件對象叫TCanvas，提供了一個Lock方法用於線程的同步，當一個線程使用此控件對象的時候，首先調用這個對象的Lock方法，而後對這個控件進行操做，完畢後再調用Unlock方法，釋放對控間的控制權。

例如：

CanversObject.look;

try

畫圖

finally

CanversObject.unlock;

end;

{使用這個保護機制,保證不論有沒有異常，unlock都會被執行不然極可能會發生死鎖。在多線程設計的時候，應該很注意發生死鎖的問題}

3、Waitfor方法

當一個線程應該等待另外一個線程結束時，能夠調用Waitfor方法。這個方法屬於等待線程對象，Waitfor方法的原型以下:

Function Waitfor(Const Astring:string):string;

好比在前面最基本的線程的例子中，喚醒線程的語句中加上

thread1.resume;

thread1.waitfor;

thread2.resume;

那麼全部的線程都必須等待thread1運行完畢後才能運行，其中包括主線程，能夠預想，因爲thread1調用了主窗體的Edit控件，那麼，在thread1運行中間，Edie1也不會顯示。

這就告訴咱們，這樣的代碼是不能做爲主線程的一部分的，若是與主窗體鏈接的線程內等待另外一個線程結束，而另外一個線程又要等待訪問用戶界面，就多是程序陷於死鎖。

這點在應用的時候要謹慎。

4、利用Windows的API

Windows API函數提供了不少同步技術，下面簡要介紹。

1. Critical Sections（臨界區），源代碼中若是有不能由兩個或兩個以上線程同時執行的部分，能夠用臨界段來使這部分的代碼執行串行化。它只能在一個獨立的進程或一個獨立的應用程序中使用。使用方法以下：

　　 //在窗體建立中

　　 InitializeCriticalSection(Critical1)

　　 //在窗體銷燬中

　　 DeleteCriticalSection(Critical1)

　　 //在線程中

　　 EnterCriticalSection(Critical1)

　　 ……保護的代碼

　　 LeaveCriticalSection(Critical1)

　　 2. Mutex（互斥對象），是用於串行化訪問資源的全局對象。咱們首先設置互斥對象，而後訪問資源，最後釋放互斥對象。在設置互斥對象時，若是另外一個線程（或進程）試圖設置相同的互斥對象，該線程將會停下來，直到前一個線程（或進程）釋放該互斥對象爲止。注意它能夠由不一樣應用程序共享。使用方法以下：

　　 //在窗體建立中

　　 hMutex:=CreateMutex(nil,false,nil)

　　 //在窗體銷燬中

　　 CloseHandle(hMutex)

　　 //在線程中

　　 WaitForSingleObject(hMutex,INFINITE)

　　 ……保護的代碼

　　 ReleaseMutex(hMutex)

　　 3. Semaphore（信號量），它與互斥對象類似，但它能夠計數。例如能夠容許一個給定資源同時同時被三個線程訪問。其實Mutex就是最大計數爲一的Semaphore。使用方法以下：

　　 //在窗體建立中

　　 hSemaphore:= CreateSemaphore(nil,lInitialCount,lMaximumCount,lpName)

　　 //在窗體銷燬中

　　 CloseHandle(hSemaphore)

　　 //在線程中

　　 WaitForSingleObject(hSemaphore,INFINITE)

　　 ……保護的代碼

　　 ReleaseSemaphore(hSemaphore, lReleaseCount, lpPreviousCount)

四、事件

delphi多線程

2017年09月30日 09:53:31 一葉青晨閱讀數：2282更多

（推薦）

我的分類： delphi

序

在瞭解多線程以前咱們先了解一下進程和線程的關係

一個程序至少有一個主進程,一個進程至少有一個線程。

爲了保證線程的安全性請你們看看下面介紹 Delphi多線程同步的一些處理方案你們能夠參考:http://www.cr173.com/html/16747_1.html

主線程又程爲UI線程。

進程和線程的主要差異在於它們是不一樣的操做系統資源管理方式。進程有獨立的地址空間，一個進程崩潰後，在保護模式下不會對其它進程產生影響，而線程只是一個進程中的不一樣執行路徑。線程有本身的堆棧和局部變量，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉，因此多進程的程序要比多線程的程序健壯，但在進程切換時，耗費資源較大，效率要差一些。但對於一些要求同時進行而且又要共享某些變量的併發操做，只能用線程，不能用進程。若是有興趣深刻的話，我建議大家看看《現代操做系統》或者《操做系統的設計與實現》。對就個問題說得比較清楚。

多線程應該是編程工做者的基礎技能, 但這個基礎我歷來沒學過，因此僅僅是看上去會一些，明白了2+2的時候，其實我還不知道1+1。

開始本應該是一篇洋洋灑灑的文字, 不過我仍是提倡先作起來, 在嘗試中去理解.

先試試這個:

procedure TForm1.Button1Click(Sender: TObject);

var

i: Integer;

begin

for i := 0 to 500000 do

begin

Canvas.TextOut(10, 10, IntToStr(i));

end;

上面程序運行時, 咱們的窗體基本是 "死" 的, 能夠在你在程序運行期間拖動窗體試試...

Delphi 爲咱們提供了一個簡單的辦法(Application.ProcessMessages)來解決這個問題:

procedure TForm1.Button1Click(Sender: TObject);

var

i: Integer;

begin

for i := 0 to 500000 do

begin

Canvas.TextOut(10, 10, IntToStr(i));

Application.ProcessMessages;

end;

這個 Application.ProcessMessages; 通常用在比較費時的循環中, 它會檢查並先處理消息隊列中的其餘消息.

但這算不上多線程, 譬如: 運行中你拖動窗體, 循環會暫停下來...

在使用多線程之前, 讓咱們先簡單修改一下程序:

function MyFun: Integer;

var

i: Integer;

begin

for i := 0 to 500000 do

begin

Form1.Canvas.Lock;

Form1.Canvas.TextOut(10, 10, IntToStr(i));

Form1.Canvas.Unlock;

end;

Result := 0;

end;

procedure TForm1.Button1Click(Sender: TObject);

begin

MyFun;

end;

細數上面程序的變化:

一、首先這還不是多線程的, 也會讓窗體假 "死" 一會;

二、把執行代碼寫在了一個函數裏, 但這個函數不屬於 TForm1 的方法, 因此使用 Canvas 是必須冠以名稱(Form1);

三、既然是個函數, (無論是否必要)都應該有返回值;

四、使用了 500001 次 Lock 和 Unlock.

Canvas.Lock 比如在說: Canvas(繪圖表面)正忙着呢, 其餘想用 Canvas 的等會;

Canvas.Unlock : 用完了, 解鎖!

在 Canvas 中使用 Lock 和 Unlock 是個好習慣, 在不使用多線程的狀況下這無所謂, 但保不許哪天程序會擴展爲多線程的; 咱們如今學習多線程, 固然應該用.

在 Delphi 中使用多線程有兩種方法: 調用 API、使用 TThread 類; 使用 API 的代碼更簡單.

function MyFun(p: Pointer): Integer; stdcall;

var

i: Integer;

begin

for i := 0 to 500000 do

begin

Form1.Canvas.Lock;

Form1.Canvas.TextOut(10, 10, IntToStr(i));

Form1.Canvas.Unlock;

end;

Result := 0;

end;

procedure TForm1.Button1Click(Sender: TObject);

var

ID: THandle;

begin

CreateThread(nil, 0, @MyFun, nil, 0, ID);

end;

代碼分析:

CreateThread 一個線程後, 算上原來的主線程, 這樣程序就有兩個線程、是標準的多線程了;

CreateThread 第三個參數是函數指針, 新線程創建後將當即執行該函數, 函數執行完畢, 系統將銷燬此線程從而結束多線程的故事.

CreateThread 要使用的函數是系統級別的, 不能是某個類(譬如: TForm1)的方法, 而且有嚴格的格式(參數、返回值)要求, 無論你暫時是否是須要都必須按格式來;

由於是系統級調用, 還要綴上 stdcall, stdcall 是協調參數順序的, 雖然這裏只有一個參數沒有順序可言, 但這是使用系統函數的慣例.

CreateThread 還須要一個 var 參數來接受新建線程的 ID, 儘管暫時沒用, 但這也是格式; 其餘參數之後再說吧.

這樣一個最簡單的多線程程序就出來了, 我們再用 TThread 類實現一次

type

TMyThread = class(TThread)

protected

procedure Execute; override;

end;

procedure TMyThread.Execute;

var

i: Integer;

begin

FreeOnTerminate := True; {這可讓線程執行完畢後隨即釋放}

for i := 0 to 500000 do

begin

Form1.Canvas.Lock;

Form1.Canvas.TextOut(10, 10, IntToStr(i));

Form1.Canvas.Unlock;

end;

procedure TForm1.Button1Click(Sender: TObject);

begin

TMyThread.Create(False);

end;

TThread 類有一個抽象方法(Execute), 於是是個抽象類, 抽象類只能繼承使用, 上面是繼承爲 TMyThread.

繼承 TThread 主要就是實現抽象方法 Execute(把咱們的代碼寫在裏面), 等咱們的 TMyThread 實例化後, 首先就會執行 Execute 方法中的代碼.

按常規咱們通常這樣去實例化:

procedure TForm1.Button1Click(Sender: TObject);

var

MyThread: TMyThread;

begin

MyThread := TMyThread.Create(False);

end;

由於 MyThread 變量在這裏毫無用處(而且編譯器還有提示), 因此不如直接寫作 TMyThread.Create(False);

咱們還能夠輕鬆解決一個問題, 若是: TMyThread.Create(True) ?

這樣線程創建後就不會當即調用 Execute, 能夠在須要的時候再用 Resume 方法執行線程, 譬如:

procedure TForm1.Button1Click(Sender: TObject);

var

MyThread: TMyThread;

begin

MyThread := TMyThread.Create(True);

MyThread.Resume;

end;

//可簡化爲:

procedure TForm1.Button1Click(Sender: TObject);

begin

with TMyThread.Create(True) do Resume;

end;

1、入門

㈠、CreateThread 函數

function CreateThread(

lpThreadAttributes: Pointer; {安全設置}

dwStackSize: DWORD; {堆棧大小}

lpStartAddress: TFNThreadStartRoutine; {入口函數}

lpParameter: Pointer; {函數參數}

dwCreationFlags: DWORD; {啓動選項}

var lpThreadId: DWORD {輸出線程 ID }

): THandle; stdcall; {返回線程句柄}

在 Windows 上創建一個線程, 離不開 CreateThread 函數;

TThread.Create 就是先調用了 BeginThread (Delphi 自定義的), BeginThread 又調用的 CreateThread.

既然有創建, 就該有釋放, CreateThread 對應的釋放函數是: ExitThread, 譬以下面代碼:

procedure TForm1.Button1Click(Sender: TObject);

begin

ExitThread(0); {此句便可退出當前程序, 但不建議這樣使用}

end;

代碼註釋:

當前程序是一個進程, 進程只是一個工做環境, 線程是工做者;

每一個進程都會有一個啓動線程(或叫主線程), 也就是說: 咱們以前大量的編碼都是寫給這個主線程的;

上面的 ExitThread(0); 就是退出這個主線程;

系統不容許一個沒有線程的進程存在, 因此程序就退出了.

另外: ExitThread 函數的參數是一個退出碼, 這個退出碼是給以後的其餘函數用的, 這裏隨便給個無符號整數便可.

或許你會說: 這個 ExitThread 挺好用的; 其實無論是用 API 仍是用 TThread 類寫多線程, 咱們不多用到它; 由於:

一、假如直接使用 API 的 CreateThread, 它執行完入口函數後會自動退出, 無需 ExitThread;

二、用 TThread 類創建的線程又毫不能使用 ExitThread 退出; 由於使用 TThread 創建線程時會同時分配更多資源(譬如你自定義的成員、還有它的祖先類(TObject)分配的資源等等), 若是用 ExitThread 給草草退出了, 這些資源將得不到釋放而致使內存泄露. 儘管 Delphi 提供了 EndThread(其內部調用 ExitThread), 這也不須要咱們手動操做(假如非要手動操做也是件很麻煩的事情, 由於不少時候你不知道線程是何時執行完畢的).

除了 CreateThread, 還有一個 CreateRemoteThread, 可在其餘進程中創建線程, 這不該該是如今學習的重點;

如今先集中精力把 CreateThread 的參數搞完全.

倒着來吧, 先談談 CreateThread 將要返回的 "線程句柄".

"句柄" 相似指針, 但經過指針可讀寫對象, 經過句柄只是使用對象;

有句柄的對象通常都是系統級別的對象(或叫內核對象); 之因此給咱們的是句柄而不是指針, 目的只有一個: "安全";

貌似經過句柄能作不少事情, 但通常把句柄提交到某個函數(通常是系統函數)後, 咱們也就到此爲止很難了解更多了; 事實上是系統並不相信咱們.

無論是指針仍是句柄, 都不過是內存中的一小塊數據(通常用結構描述), 微軟並無公開句柄的結構細節, 猜一下它應該包括: 真實的指針地址、訪問權限設置、引用計數等等.

既然 CreateThread 能夠返回一個句柄, 說明線程屬於 "內核對象".

實際上無論線程屬於哪一個進程, 它們在系統的懷抱中是平等的; 在優先級(後面詳談)相同的狀況下, 系統會在相同的時間間隔內來運行一下每一個線程, 不過這個間隔很小很小, 以致於讓咱們誤覺得程序是在不間斷地運行.

這時你應該有一個疑問: 系統在去執行其餘線程的時候, 是怎麼記住前一個線程的數據狀態的?

有這樣一個結構 TContext, 它基本上是一個 CPU 寄存器的集合, 線程是數據就是經過這個結構切換的, 咱們也能夠經過 GetThreadContext 函數讀取寄存器看看.

附上這個結構 TContext(或叫: CONTEXT、_CONTEXT) 的定義:

PContext = ^TContext;

_CONTEXT = record

ContextFlags: DWORD;

Dr0: DWORD;

Dr1: DWORD;

Dr2: DWORD;

Dr3: DWORD;

Dr6: DWORD;

Dr7: DWORD;

FloatSave: TFloatingSaveArea;

SegGs: DWORD;

SegFs: DWORD;

SegEs: DWORD;

SegDs: DWORD;

Edi: DWORD;

Esi: DWORD;

Ebx: DWORD;

Edx: DWORD;

Ecx: DWORD;

Eax: DWORD;

Ebp: DWORD;

Eip: DWORD;

SegCs: DWORD;

EFlags: DWORD;

Esp: DWORD;

SegSs: DWORD;

end;

CreateThread 的最後一個參數是 "線程的 ID";

既然能夠返回句柄, 爲何還要輸出這個 ID? 如今我知道的是:

一、線程的 ID 是惟一的; 而句柄可能不僅一個, 譬如能夠用 GetCurrentThread 獲取一個僞句柄、能夠用 DuplicateHandle 複製一個句柄等等.

二、ID 比句柄更輕便.

在主線程中 GetCurrentThreadId、MainThreadID、MainInstance 獲取的都是主線程的 ID.

㈡、啓動選項

function CreateThread(

lpThreadAttributes: Pointer;

dwStackSize: DWORD;

lpStartAddress: TFNThreadStartRoutine;

lpParameter: Pointer;

dwCreationFlags: DWORD; {啓動選項}

var lpThreadId: DWORD

): THandle; stdcall;

CreateThread 的倒數第二個參數 dwCreationFlags(啓動選項) 有兩個可選值:

0: 線程創建後當即執行入口函數;

CREATE_SUSPENDED: 線程創建後會掛起等待.

可用 ResumeThread 函數是恢復線程的運行; 可用 SuspendThread 再次掛起線程.

這兩個函數的參數都是線程句柄, 返回值是執行前的掛起計數.

什麼是掛起計數?

SuspendThread 會給這個數 +1; ResumeThread 會給這個數 -1; 但這個數最小是 0.

當這個數 = 0 時, 線程會運行; > 0 時會掛起.

若是被 SuspendThread 屢次, 一樣須要 ResumeThread 屢次才能恢復線程的運行.

在下面的例子中, 有新線程不斷給一個全局變量賦隨機值;

同時窗體上的 Timer 控件每隔 1/10 秒就把這個變量寫在窗體標題;

在這個過程當中演示了 ResumeThread、SuspendThread 兩個函數.

//上面圖片中演示的代碼。

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls, ExtCtrls;

type

TForm1 = class(TForm)

Button1: TButton;

Button2: TButton;

Button3: TButton;

Timer1: TTimer;

procedure Button1Click(Sender: TObject);

procedure Button2Click(Sender: TObject);

procedure Button3Click(Sender: TObject);

procedure FormCreate(Sender: TObject);

procedure Timer1Timer(Sender: TObject);

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

var

hThread: THandle; {線程句柄}

num: Integer; {全局變量, 用於記錄隨機數}

{線程入口函數}

function MyThreadFun(p: Pointer): Integer; stdcall;

begin

while True do {假如線程不掛起, 這個循環將一直循環下去}

begin

num := Random(100);

end;

Result := 0;

end;

{創建並掛起線程}

procedure TForm1.Button1Click(Sender: TObject);

var

ID: DWORD;

begin

hThread := CreateThread(nil, 0, @MyThreadFun, nil, CREATE_SUSPENDED, ID);

Button1.Enabled := False;

end;

{喚醒並繼續線程}

procedure TForm1.Button2Click(Sender: TObject);

begin

ResumeThread(hThread);

end;

{掛起線程}

procedure TForm1.Button3Click(Sender: TObject);

begin

SuspendThread(hThread);

end;

procedure TForm1.FormCreate(Sender: TObject);

begin

Timer1.Interval := 100;

end;

procedure TForm1.Timer1Timer(Sender: TObject);

begin

Text := IntToStr(num);

end;

end.

㈢、入口函數的參數

function CreateThread(

lpThreadAttributes: Pointer;

dwStackSize: DWORD;

lpStartAddress: TFNThreadStartRoutine;

lpParameter: Pointer; {入口函數的參數}

dwCreationFlags: DWORD;

var lpThreadId: DWORD

): THandle; stdcall;

線程入口函數的參數是個無類型指針(Pointer), 用它能夠指定任何數據; 本例是把鼠標點擊窗體的座標傳遞給線程的入口函數, 每次點擊窗體都會建立一個線程.

運行效果圖:

//上面演示的代碼

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs;

type

TForm1 = class(TForm)

procedure FormMouseUp(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

var

pt: TPoint; {這個座標點將會已指針的方式傳遞給線程, 它應該是全局的}

function MyThreadFun(p: Pointer): Integer; stdcall;

var

i: Integer;

pt2: TPoint; {由於指針參數給的點隨時都在變, 需用線程的局部變量存起來}

begin

pt2 := PPoint(p)^; {轉換}

for i := 0 to 1000000 do

begin

with Form1.Canvas do begin

Lock;

TextOut(pt2.X, pt2.Y, IntToStr(i));

Unlock;

end;

Result := 0;

end;

procedure TForm1.FormMouseUp(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

var

ID: DWORD;

begin

pt := Point(X, Y);

CreateThread(nil, 0, @MyThreadFun, @pt, 0, ID);

{下面這種寫法更好理解, 其實沒必要, 由於 PPoint 會自動轉換爲 Pointer 的}

//CreateThread(nil, 0, @MyThreadFun, Pointer(@pt), 0, ID);

end;

end.

這個例子還有不嚴謹的地方: 當一個線程 Lock 窗體的 Canvas 時, 其餘線程在等待; 線程在等待時, 其中的計數也還在增長. 這也就是說: 如今並無去處理線程的同步; 同步是多線程中最重要的課題, 快到了.

另外有個小技巧: 線程函數的參數是個 32 位(4個字節)的指針, 僅就本例來說, 可讓它的 "高16位" 和 "低16位" 分別攜帶 X 和 Y; 這樣就不須要哪一個全局的 pt 變量了.

其實在 Windows 的消息中就是這樣傳遞座標的, 在 Windows 的消息中通常高字節是 Y、低字節是 X; 我們這麼來吧, 這樣還能夠使用給消息準備的一些方便的函數.

重寫本例代碼(固然運行效果和窗體文件都是同樣的):

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs;

type

TForm1 = class(TForm)

procedure FormMouseUp(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

function MyThreadFun(p: Pointer): Integer; stdcall;

var

i: Integer;

x,y: Word;

begin

x := LoWord(Integer(p));

y := HiWord(Integer(p));

{若是不使用 LoWord、HiWord 函數能夠像下面這樣: }

//x := Integer(p);

//y := Integer(p) shr 16;

for i := 0 to 1000000 do

begin

with Form1.Canvas do begin

Lock;

TextOut(x, y, IntToStr(i));

Unlock;

end;

Result := 0;

end;

procedure TForm1.FormMouseUp(Sender: TObject; Button: TMouseButton;

Shift: TShiftState; X, Y: Integer);

var

ID: DWORD;

num: Integer;

begin

num := MakeLong(X, Y);

{若是不使用 MekeLong、MakeWParam、MakeLParam、MakeResult 等函數, 能夠像下面這樣: }

//num := Y shl 16 + X;

CreateThread(nil, 0, @MyThreadFun, Ptr(num), 0, ID);

{上面的 Ptr 是專門將一個數字轉換爲指針的函數, 固然也能夠這樣: }

//CreateThread(nil, 0, @MyThreadFun, Pointer(num), 0, ID);

end;

end.

㈣、入口函數的指針

function CreateThread(

lpThreadAttributes: Pointer;

dwStackSize: DWORD;

lpStartAddress: TFNThreadStartRoutine; {入口函數的指針}

lpParameter: Pointer;

dwCreationFlags: DWORD;

var lpThreadId: DWORD

): THandle; stdcall;

到了入口函數了, 學到這個地方, 我查了一個入口函數的標準定義, 這個函數的標準返回值應該是 DWORD, 不過這函數在 Delphi 的 System 單元定義的是: TThreadFunc = function(Parameter: Pointer): Integer; 我之後會盡可能使用 DWORD 作入口函數的返回值.

這個返回值有什麼用呢?

等線程退出後, 咱們用 GetExitCodeThread 函數獲取的退出碼就是這個返回值!

若是線程沒有退出, GetExitCodeThread 獲取的退出碼將是一個常量 STILL_ACTIVE (259); 這樣咱們就能夠經過退出碼來判斷線程是否已退出.

還有一個問題: 前面也提到過, 線程函數不能是某個類的方法! 假如咱們非要線程去執行類中的一個方法可否實現呢?

儘管能夠用 Addr(類名.方法名) 或 MethodAddress('published 區的方法名') 獲取類中方法的地址, 但都不能當作線程的入口函數, 緣由多是由於類中的方法的地址是在實例化爲對象時動態分配的.

後來換了個思路, 其實很簡單: 在線程函數中再調用方法不就得了, 估計 TThread 也應該是這樣.

下面的例子就嘗試了用線程調用 TForm1 類中的方法, 並測試了退出碼的相關問題.

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls;

type

TForm1 = class(TForm)

Button1: TButton;

Button2: TButton;

procedure Button1Click(Sender: TObject);

procedure Button2Click(Sender: TObject);

private

procedure FormProc; {準備給線程使用的方法}

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

var

hThread: THandle;

{線程入口函數}

function MyThreadFun(p: Pointer): DWORD; stdcall;

begin

Form1.FormProc; {調用 TForm1 類的方法}

Result := 99; {這個返回值將成爲線程的退出代碼, 99 是我隨意給的數字}

end;

{TForm1 的方法, 本例中是給線程的入口函數調用的}

procedure TForm1.FormProc;

var

i: Integer;

begin

for i := 0 to 200000 do

begin

with Form1.Canvas do begin

Lock;

TextOut(10, 10, IntToStr(i));

Unlock;

end;

{創建並執行線程}

procedure TForm1.Button1Click(Sender: TObject);

var

ID: DWORD;

begin

hThread := CreateThread(nil, 0, @MyThreadFun, nil, 0, ID);

end;

{獲取線程的退出代碼, 並判斷線程是否退出}

procedure TForm1.Button2Click(Sender: TObject);

var

ExitCode: DWORD;

begin

GetExitCodeThread(hThread, ExitCode);

if hThread = 0 then

begin

Text := '線程還未啓動';

Exit;

end;

if ExitCode = STILL_ACTIVE then

Text := Format('線程退出代碼是: %d, 表示線程還未退出', [ExitCode])

else

Text := Format('線程已退出, 退出代碼是: %d', [ExitCode]);

end;

end.

㈤、堆棧大小

function CreateThread(

lpThreadAttributes: Pointer;

dwStackSize: DWORD; {堆棧大小}

lpStartAddress: TFNThreadStartRoutine;

lpParameter: Pointer;

dwCreationFlags: DWORD;

var lpThreadId: DWORD

): THandle; stdcall;

CreateThread 的第二個參數是分配給線程的堆棧大小.

這首先這可讓咱們知道: 每一個線程都有本身獨立的堆棧(也擁有本身的消息隊列).

什麼是堆棧? 其實堆是堆、棧是棧, 有時 "棧" 也被叫作 "堆棧".

它們都是進程中的內存區域, 主要是存取方式不一樣(棧:先進後出; 堆:先進先出);

"棧"(或叫堆棧)適合存取臨時而輕便的變量, 主要用來儲存局部變量; 譬如 for i := 0 to 99 do 中的 i 就只能存於棧中, 你把一個全局的變量用於 for 循環計數是不能夠的.

如今咱們知道了線程有本身的 "棧", 而且在創建線程時能夠分配棧的大小.

前面全部的例子中, 這個值都是 0, 這表示使用系統默認的大小, 默認和主線程棧的大小同樣, 若是不夠用會自動增加;

那主線程的棧有多大? 這個值是能夠設定的: Project -> Options -> linker -> memory size(如圖)

棧是私有的但堆是公用的, 若是不一樣的線程都來使用一個全局變量有點亂套;

爲解決這個問題 Delphi 爲咱們提供了一個相似 var 的 ThreadVar 關鍵字, 線程在使用 ThreadVar 聲明的全局變量時會在各自的棧中留一個副本, 這樣就解決了衝突. 不過仍是儘可能使用局部變量, 或者在繼承 TThread 時使用類的成員變量, 由於 ThreadVar 的效率很差, 聽說比局部變量能慢 10 倍.

在下面的例子就測試了用 var 和 ThreadVar 定義變量的不一樣.

使用 var 效果圖:

使用 ThreadVar 效果圖:

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls;

type

TForm1 = class(TForm)

Button1: TButton;

procedure Button1Click(Sender: TObject);

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

//var num: Integer; {全局變量}

threadvar num: Integer; {支持多線程的全局變量}

function MyThreadFun(p: Pointer): DWORD; stdcall;

var

py: Integer;

begin

py := Integer(p);

while True do

begin

Inc(num);

with Form1.Canvas do begin

Lock;

TextOut(20, py, IntToStr(num));

Unlock;

end;

Sleep(1000); {然線程掛起 1 秒鐘再繼續}

end;

procedure TForm1.Button1Click(Sender: TObject);

var

ID: DWORD;

begin

{借入口函數的參數傳遞了一個座標點中的 Y 值, 以讓各線程把結果輸出在不一樣位置}

CreateThread(nil, 0, @MyThreadFun, Ptr(20), 0, ID);

CreateThread(nil, 0, @MyThreadFun, Ptr(40), 0, ID);

CreateThread(nil, 0, @MyThreadFun, Ptr(60), 0, ID);

end;

end.

㈥、安全設置

function CreateThread(

lpThreadAttributes: Pointer; {安全設置}

dwStackSize: DWORD;

lpStartAddress: TFNThreadStartRoutine;

lpParameter: Pointer;

dwCreationFlags: DWORD;

var lpThreadId: DWORD

): THandle; stdcall;

CreateThread 的第一個參數 lpThreadAttributes 是指向 TSecurityAttributes 結構的指針, 通常都是置爲 nil, 這表示沒有訪問限制; 該結構的定義是:

//TSecurityAttributes(又名: SECURITY_ATTRIBUTES、_SECURITY_ATTRIBUTES)

_SECURITY_ATTRIBUTES = record

nLength: DWORD; {結構大小}

lpSecurityDescriptor: Pointer; {默認 nil; 這是另外一個結構 TSecurityDescriptor 的指針}

bInheritHandle: BOOL; {默認 False, 表示不可繼承}

end;

//TSecurityDescriptor(又名: SECURITY_DESCRIPTOR、_SECURITY_DESCRIPTOR)

_SECURITY_DESCRIPTOR = record

Revision: Byte;

Sbz1: Byte;

Control: SECURITY_DESCRIPTOR_CONTROL;

Owner: PSID;

Group: PSID;

Sacl: PACL;

Dacl: PACL;

end;

夠複雜的, 但咱們在多線程編程時不須要去設置它們, 大都是使用默認設置(也就是賦值爲 nil).

我以爲有必要在此刻了解的是: 創建系統內核對象時通常都有這個屬性(TSecurityAttributes);

在接下來多線程的課題中要使用一些內核對象, 不如先盤點一下, 到時碰到這個屬性時給個 nil 便可, 沒必要再費神.

{創建事件}

function CreateEvent(

lpEventAttributes: PSecurityAttributes; {!}

bManualReset: BOOL;

bInitialState: BOOL;

lpName: PWideChar

): THandle; stdcall;

{創建互斥}

function CreateMutex(

lpMutexAttributes: PSecurityAttributes; {!}

bInitialOwner: BOOL;

lpName: PWideChar

): THandle; stdcall;

{創建信號}

function CreateSemaphore(

lpSemaphoreAttributes: PSecurityAttributes; {!}

lInitialCount: Longint;

lMaximumCount: Longint;

lpName: PWideChar

): THandle; stdcall;

{創建等待計時器}

function CreateWaitableTimer(

lpTimerAttributes: PSecurityAttributes; {!}

bManualReset: BOOL;

lpTimerName: PWideChar

): THandle; stdcall;

上面的四個系統內核對象(事件、互斥、信號、計時器)都是線程同步的手段, 從這也能看出處理線程同步的複雜性; 不過這還不是所有, Windows Vista 開始又增長了 Condition variables(條件變量)、Slim Reader-Writer Locks(讀寫鎖)等同步手段.

不過最簡單、最輕便(速度最快)的同步手段仍是 CriticalSection(臨界區), 但它不屬於系統內核對象, 固然也就沒有句柄、沒有 TSecurityAttributes 這個安全屬性, 這也致使它不能跨進程使用; 不過寫多線程時通常不用跨進程, 因此 CriticalSection 應該是最經常使用的同步手段.

2、線程同步之臨界區。

先看一段程序, 代碼文件:

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls;

type

TForm1 = class(TForm)

ListBox1: TListBox;

Button1: TButton;

procedure FormCreate(Sender: TObject);

procedure Button1Click(Sender: TObject);

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

function MyThreadFun(p: Pointer): DWORD; stdcall;

var

i: Integer;

begin

for i := 0 to 99 do Form1.ListBox1.Items.Add(IntToStr(i));

Result := 0;

end;

procedure TForm1.Button1Click(Sender: TObject);

var

ID: DWORD;

begin

CreateThread(nil, 0, @MyThreadFun, nil, 0, ID);

end;

procedure TForm1.FormCreate(Sender: TObject);

begin

ListBox1.Align := alLeft;

end;

end.

在這段程序中, 有三個線程幾乎是同時創建, 向窗體中的 ListBox1 中寫數據, 最後寫出的結果是這樣的:

能不能讓它們別打架, 一個完了另外一個再來? 這就要用到多線程的同步技術.

前面說過, 最簡單的同步手段就是 "臨界區".

先說這個 "同步"(Synchronize), 首先這個名字起的很差, 咱們好像須要的是 "異步"; 其實異步也不許確...

管它叫什麼名字呢, 它的目的就是保證不衝突、有次序、都發生.

"臨界區"(CriticalSection): 當把一段代碼放入一個臨界區, 線程執行到臨界區時就獨佔了, 讓其餘也要執行此代碼的線程先等等; 這和前面用的 Lock 和 UnLock 差很少; 使用格式以下:

var CS: TRTLCriticalSection; {聲明一個 TRTLCriticalSection 結構類型變量; 它應該是全局的}

InitializeCriticalSection(CS); {初始化}

EnterCriticalSection(CS); {開始: 輪到我了其餘線程走開}

LeaveCriticalSection(CS); {結束: 其餘線程能夠來了}

DeleteCriticalSection(CS); {刪除: 注意不能過早刪除}

//也可用 TryEnterCriticalSection 替代 EnterCriticalSection.

用上臨界區, 重寫上面的代碼, 運行效果圖:

//用臨界區重寫後的代碼文件:

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls;

type

TForm1 = class(TForm)

ListBox1: TListBox;

Button1: TButton;

procedure FormCreate(Sender: TObject);

procedure FormDestroy(Sender: TObject);

procedure Button1Click(Sender: TObject);

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

var

CS: TRTLCriticalSection;

function MyThreadFun(p: Pointer): DWORD; stdcall;

var

i: Integer;

begin

EnterCriticalSection(CS);

for i := 0 to 99 do Form1.ListBox1.Items.Add(IntToStr(i));

LeaveCriticalSection(CS);

Result := 0;

end;

procedure TForm1.Button1Click(Sender: TObject);

var

ID: DWORD;

begin

CreateThread(nil, 0, @MyThreadFun, nil, 0, ID);

end;

procedure TForm1.FormCreate(Sender: TObject);

begin

ListBox1.Align := alLeft;

InitializeCriticalSection(CS);

end;

procedure TForm1.FormDestroy(Sender: TObject);

begin

DeleteCriticalSection(CS);

end;

end.

Delphi 在 SyncObjs 單元給封裝了一個 TCriticalSection 類, 用法差很少, 代碼以下:

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls;

type

TForm1 = class(TForm)

ListBox1: TListBox;

Button1: TButton;

procedure FormCreate(Sender: TObject);

procedure FormDestroy(Sender: TObject);

procedure Button1Click(Sender: TObject);

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

uses SyncObjs;

var

CS: TCriticalSection;

function MyThreadFun(p: Pointer): DWORD; stdcall;

var

i: Integer;

begin

CS.Enter;

for i := 0 to 99 do Form1.ListBox1.Items.Add(IntToStr(i));

CS.Leave;

Result := 0;

end;

procedure TForm1.Button1Click(Sender: TObject);

var

ID: DWORD;

begin

CreateThread(nil, 0, @MyThreadFun, nil, 0, ID);

end;

procedure TForm1.FormCreate(Sender: TObject);

begin

ListBox1.Align := alLeft;

CS := TCriticalSection.Create;

end;

procedure TForm1.FormDestroy(Sender: TObject);

begin

CS.Free;

end;

end.

3、等待函數aitForSingleObject

一會兒跳到等待函數 WaitForSingleObject, 是由於下面的 Mutex、Semaphore、Event、WaitableTimer 等同步手段都要使用這個函數; 不過等待函數可不止 WaitForSingleObject 它一個, 但它最簡單.

function WaitForSingleObject(

hHandle: THandle; {要等待的對象句柄}

dwMilliseconds: DWORD {等待的時間, 單位是毫秒}

): DWORD; stdcall; {返回值以下:}

WAIT_OBJECT_0 {等着了, 本例中是: 等的那個進程終於結束了}

WAIT_TIMEOUT {等過了點(你指定的時間), 也沒等着}

WAIT_ABANDONED {好不容易等着了, 但人家仍是不讓咱執行; 這通常是互斥對象}

//WaitForSingleObject 的第二個參數通常給常數值 INFINITE, 表示一直等下去, 死等.

WaitForSingleObject 等待什麼? 在多線程裏就是等待另外一個線程的結束, 快來執行本身的代碼; 不過它能夠等待的對象可不止線程; 這裏先來一個等待另外一個進程結束的例子, 運行效果圖:

//WaitForSingleObject的示例代碼文件:

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls;

type

TForm1 = class(TForm)

Button1: TButton;

procedure Button1Click(Sender: TObject);

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

var

hProcess: THandle; {進程句柄}

{等待一個指定句柄的進程何時結束}

function MyThreadFun(p: Pointer): DWORD; stdcall;

begin

if WaitForSingleObject(hProcess, INFINITE) = WAIT_OBJECT_0 then

Form1.Text := Format('進程 %d 已關閉', [hProcess]);

Result := 0;

end;

{啓動一個進程, 並創建新線程等待它的結束}

procedure TForm1.Button1Click(Sender: TObject);

var

pInfo: TProcessInformation;

sInfo: TStartupInfo;

Path: array[0..MAX_PATH-1] of Char;

ThreadID: DWORD;

begin

{先獲取記事本的路徑}

GetSystemDirectory(Path, MAX_PATH);

StrCat(Path, '\notepad.exe');

{用 CreateProcess 打開記事本並獲取其進程句柄, 而後創建線程監視}

FillChar(sInfo, SizeOf(sInfo), 0);

if CreateProcess(Path, nil, nil, nil, False, 0, nil, nil, sInfo, pInfo) then

begin

hProcess := pInfo.hProcess; {獲取進程句柄}

Text := Format('進程 %d 已啓動', [hProcess]);

CreateThread(nil, 0, @MyThreadFun, nil, 0, ThreadID); {創建線程監視}

end;

end.

Delphi TThread類詳解

咱們常有工做線程和主線程之分，工做線程負責做一些後臺操做，好比接收郵件；主線程負責界面上的一些顯示。工做線程的好處在某些時候是不言而喻的，你的主界面能夠響應任何操做，而背後的線程卻在默默地工做。

VCL中，工做線程執行在Execute方法中，你必須從TThread繼承一個類並覆蓋Execute方法，在這個方法中，全部代碼都是在另外一個線程中執行的，除此以外，你的線程類的其餘方法都在主線程執行，包括構造方法，析構方法，Resume等，不少人經常忽略了這一點。

最簡單的一個線程類以下：

TMyThread = class(TThread)

protected

procedure Execute; override;

end;

在Execute中的代碼，有一個技術要點，若是你的代碼執行時間很短，像這樣，Sleep(1000)，那沒有關係；若是是這樣Sleep (10000)，10秒，那麼你就不能直接這樣寫了，須把這10秒拆分紅10個1秒，而後判斷Terminated屬性，像下面這樣：

procedure TMyThread.Execute;

var

i: Integer;

begin

for i := 0 to 9 do

if not Terminated then

Sleep(1000)

else

Break;

end;

這樣寫有什麼好處呢，想一想你要關閉程序，在關閉的時候調用MyThread.Free，這個時候線程並無立刻結束，它調用WaitFor，等待 Execute執行完後才能釋放。你的程序就必須等10秒之後才能關閉，受得了嗎。若是像上面那樣寫，在程序關閉時，調用Free以後，它頂多再等一秒就會關閉。爲何？答案得去線程類的Destroy中找，它會先調用Terminate方法，在這個方法裏面它把Terminated設爲True（僅此而已，不少人覺得是結束線程，其實不是）。請記住這一切是在主線程中操做的，因此和Execute是並行執行的。既然Terminated屬性已爲 Ture，那麼在Execute中判斷以後，固然就Break了，Execute執行完畢，線程類也正常釋放。

或者有人說，TThread能夠設FreeOnTerminate屬性爲True，線程類就能自動釋放。除非你的線程執行的任務很簡單，否則，仍是不要去理會這個屬性，一切由你來操做，才能使線程更靈活強大。

接下來的問題是如何使工做線程和主線程很好的通訊，不少時候主線程必須獲得工做線程的通知，才能作出響應。好比接收郵件，工做線程向服務器收取郵件，收取完畢以後，它得通知主線程收到多少封郵件，主線程才能彈出一個窗口通知用戶。

在VCL中，咱們能夠用兩種方法，一種是向主線程中的窗體發送消息，另外一種是使用異步事件。第一種方法其實沒有第二種來得方便。想一想線程類中的OnTerminate事件，這個事件由線程函數的堆棧引發，卻在主線程執行。

事實上，真正的線程函數是這個：

function ThreadProc(Thread: TThread): Integer;

函數裏面有Thread.Execute，這就是爲何Execute是在其餘線程中執行，該方法執行以後，有以下句：

Thread.DoTerminate;

而線程類的DoTerminate方法裏面是

if Assigned(FOnTerminate) then Synchronize(CallOnTerminate);

顯然Synchronize方法使得CallOnTerminate在主線程中執行，而CallOnTerminate裏面的代碼其實就是：

if Assigned(FOnTerminate) then FOnTerminate(Self);

只要Execute方法一執行完就發生OnTerminate事件。不過有一點是必須注意，OnTerminate事件發生後，線程類不必定會釋放，只有在FreeOnTerminate爲True以後，纔會Thread.Free。看一下ThreadProc函數就知道。

依照Onterminate事件，咱們能夠設計本身的異步事件。

Synchronize方法只能傳進一個無參數的方法類型，但咱們的事件常常是要帶一些參數的，這個稍加思考就能夠獲得解決，即在線程類中保存參數，觸發事件前先設置參數，再調用異步事件，參數複雜的能夠用記錄或者類來實現。

假設這樣，上面的代碼每睡一秒，線程即向外面引起一次事件，咱們的類能夠這樣設計：

TSecondEvent = procedure (Second: Integer) of object;

TMyThread = class(TThread)

private

FSecond: Integer;

FSecondEvent: TSecondEvent;

procedure CallSecondEvent;

protected

procedure Execute; override;

public

property SencondEvent: TSecondEvent read FSecondEvent

write FSecondEvent;

end;

{ TMyThread }

procedure TMyThread.CallSecondEvent;

begin

if Assigned(FSecondEvent) then

FSecondEvent(FSecond);

end;

procedure TMyThread.Execute;

var

i: Integer;

begin

for i := 0 to 9 do

if not Terminated then

begin

Sleep(1000);

FSecond := i;

Synchronize(CallSecondEvent);

end

else

Break;

end;

在主窗體中假設咱們這樣操做線程：

procedure TForm1.Button1Click(Sender: TObject);

begin

MyThread := TMyThread.Create(true);

MyThread.OnTerminate := ThreadTerminate;

MyThread.SencondEvent := SecondEvent;

MyThread.Resume;

end;

procedure TForm1.ThreadTerminate(Sender: TObject);

begin

ShowMessage('ok');

end;

procedure TForm1.SecondEvent(Second: Integer);

begin

Edit1.Text := IntToStr(Second);

end;

咱們將每隔一秒就獲得一次通知並在Edit中顯示出來。

如今咱們已經知道如何正確使用Execute方法，以及如何在主線程與工做線程之間通訊了。但問題尚未結束，有一種狀況出乎個人意料以外，即若是線程中有一些資源，Execute正在使用這些資源，而主線程要釋放這個線程，這個線程在釋放的過程當中會釋放掉資源。想一想會不會有問題呢，兩個線程，一個在使用資源，一個在釋放資源，會出現什麼狀況呢，

用下面代碼來講明：

type

TMyClass = class

private

FSecond: Integer;

public

procedure SleepOneSecond;

end;

TMyThread = class(TThread)

private

FMyClass: TMyClass;

protected

procedure Execute; override;

public

constructor MyCreate(CreateSuspended: Boolean);

destructor Destroy; override;

end;

implementation

{ TMyThread }

constructor TMyThread.MyCreate(CreateSuspended: Boolean);

begin

inherited Create(CreateSuspended);

FMyClass := TMyClass.Create;

end;

destructor TMyThread.Destroy;

begin

FMyClass.Free;

FMyClass := nil;

inherited;

end;

procedure TMyThread.Execute;

var

i: Integer;

begin

for i := 0 to 9 do

FMyClass.SleepOneSecond;

end;

{ TMyClass }

procedure TMyClass.SleepOneSecond;

begin

FSecond := 0;

Sleep(1000);

end;

end.

用下面的代碼來調用上面的類：

procedure TForm1.Button1Click(Sender: TObject);

begin

MyThread := TMyThread.MyCreate(true);

MyThread.OnTerminate := ThreadTerminate;

MyThread.Resume;

end;

procedure TForm1.Button2Click(Sender: TObject);

begin

MyThread.Free;

end;

先點擊Button1建立一個線程，再點擊Button2釋放該類，出現什麼狀況呢，違法訪問，是的，MyThread.Free時，MyClass被釋放掉了

FMyClass.Free;

FMyClass := nil;

而此時Execute卻還在執行，而且調用MyClass的方法，固然就出現違法訪問。對於這種狀況，有什麼辦法來防止呢，我想到一種方法，即在線程類中使用一個成員，假設爲FFinished，在Execute方法中有以下的形式：

FFinished := False;

try

//... ...

finally

FFinished := True;

End;

接着在線程類的Destroy中有以下形式：

While not FFinished do

Sleep(100);

MyClass.Free;

這樣便能保證MyClass能被正確釋放。

線程是一種頗有用的技術。但使用不當，常令人頭痛。在CSDN論壇上看到一些人問，個人窗口在線程中調用爲何出錯，主線程怎麼向其餘線程發送消息等等，其實，咱們在抱怨線程難用時，也要想一想咱們使用的方法對不對，只要遵循一些正確的使用規則，線程其實很簡單。

後記

上面有一處代碼有些奇怪：FMyClass.Free; FMyClass := nil;若是你只寫FMyClass.Free，線程類還不會出現異常，即調用FMyClass.SleepOneSecond不會出錯。我在主線程中試了下面的代碼

MyClass := TMyClass.Create;

MyClass.SleepOneSecond;

MyClass.Free;

MyClass.SleepOneSecond;

一樣也不會出錯，但關閉程序時就出錯了，若是是這樣：

MyClass := TMyClass.Create;

MyClass.SleepOneSecond;

MyClass.Free;

MyThread := TMyThread.MyCreate(true);

MyThread.OnTerminate := ThreadTerminate;

MyThread.Resume;

MyClass.SleepOneSecond;

立刻就出錯。因此這個和線程類無線，應該是Delphi對於堆棧空間的釋放規則，我想MyClass.Free以後，該對象在堆棧上空間仍是保留着，只是容許其餘資源使用這個空間，因此接着調用下面這一句MyClass.SleepOneSecond就不會出錯，當程序退出時可能對堆棧做一些清理致使出錯。而若是MyClass.Free以後即建立MyThread，大概MyClass的空間已經被MyThread使用，因此再調用 MyClass.SleepOneSecond就出錯了。

DELPHI 多線程之TThread類的實現

TThread類

先新建一個普通的工程，再新建一個線程類File>>New>>Othre>>Delphi File>Thread Object，取個名字，DELPHI會自動生成一個單元，咱們只需往裏簡單添加功能代碼，和在要使用的單元裏實例引用便可。

爲了節省篇幅，現把TMyThread類集成主窗體單元裏，在窗體單元裏聲明類也是能夠的。

例：用工做線程在窗體輸出0~500000的數字。

1 unit Unit1;

3 interface

5 uses

6 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

7 Dialogs, StdCtrls;

9 type

10 TMyThread = class(TThread)

11 private

12 { Private declarations }

13 protected

14 procedure Execute; override; {執行}

15 procedure Run; {聲明多一個過程，把功能代碼寫在這裏再給Execute調用}

16 end;

17 TForm1 = class(TForm)

18 btn1: TButton;

19 procedure btn1Click(Sender: TObject);

20 private

21 { Private declarations }

22 public

23 { Public declarations }

24 end;

28 var

29 Form1: TForm1;

32 implementation

34 {$R *.dfm}

36 var

37 MyThread:TMyThread; {聲明一個線程類對象]

39 procedure TMyThread.Execute;

40 begin

41 { Place thread code here }

42 FreeOnTerminate:=True; {加上這句線程用完了會自動註釋}

43 Run;

44 end;

46 procedure TMyThread.Run;

47 var

48 i:integer;

49 begin

50 for i := 0 to 500000 do

51 begin

52 Form1.Canvas.Lock;

53 Form1.Canvas.TextOut(10,10,IntToStr(i));

54 Form1.Canvas.Unlock;

55 end;

56 end;

58 procedure TForm1.btn1Click(Sender: TObject);

59 begin

60 MyThread:=TMyThread.Create(False); {實例化這個類，爲False時當即運行，爲True時可加MyThread.Resume用來啓動}

61 end;

CriticalSection(臨界區)

uses SyncObjs;用TCriticalSection類的方法處理。

例：用三個線程，按順序給ListBox添加0~99.

1 unit Unit1;

3 interface

5 uses

6 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

7 Dialogs, StdCtrls;

9 type

10 TMyThread = class(TThread)

11 private

12 { Private declarations }

13 protected

14 procedure Execute; override; {執行}

15 procedure Run; {運行}

16 end;

17 TForm1 = class(TForm)

18 btn1: TButton;

19 lst1: TListBox;

20 procedure btn1Click(Sender: TObject);

21 procedure FormDestroy(Sender: TObject);

22 private

23 { Private declarations }

24 public

25 { Public declarations }

26 end;

30 var

31 Form1: TForm1;

34 implementation

36 {$R *.dfm}

38 uses SyncObjs;

40 var

41 MyThread:TMyThread; {聲明線程}

42 CS:TCriticalSection; {聲明臨界}

45 procedure TMyThread.Execute;

46 begin

47 { Place thread code here }

48 FreeOnTerminate:=True; {加上這句線程用完了會自動註釋}

49 Run; {運行}

50 end;

52 procedure TMyThread.Run;

53 var

54 i:integer;

55 begin

56 CS.Enter; {我要用了，其它人等下}

57 for i := 0 to 100 - 1 do

58 begin

59 Form1.lst1.Items.Add(IntToStr(i));

60 end;

61 CS.Leave; {我用完了，下一個}

62 end;

64 procedure TForm1.btn1Click(Sender: TObject);

65 begin

66 CS:=TCriticalSection.Create; {實例化臨界}

67 MyThread:=TMyThread.Create(False); {實例化這個類，爲False時當即運行，爲True時可加MyThread.Resume用來啓動}

68 MyThread:=TMyThread.Create(False);

69 MyThread:=TMyThread.Create(False);

70 end;

73 procedure TForm1.FormDestroy(Sender: TObject);

74 begin

75 CS.Free;{釋放臨界體}

76 end;

78 end.

Mutex (互斥對象)

uses SyncObjs;用TMutex類的方法處理(把釋放語句放在循環內外能夠決定執行順序)

例：互斥輸出三個0~2000的數字到窗體在不一樣位置。

1 unit Unit1;

3 interface

5 uses

6 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

7 Dialogs, StdCtrls;

9 type

10 TMyThread = class(TThread)

11 private

12 { Private declarations }

13 protected

14 procedure Execute; override; {執行}

15 procedure Run; {運行}

16 end;

17 TForm1 = class(TForm)

18 btn1: TButton;

19 procedure FormDestroy(Sender: TObject);

20 procedure btn1Click(Sender: TObject);

21 private

22 { Private declarations }

23 public

24 { Public declarations }

25 end;

29 var

30 Form1: TForm1;

33 implementation

35 {$R *.dfm}

37 uses SyncObjs;

39 var

40 MyThread:TMyThread; {聲明線程}

41 Mutex:TMutex; {聲明互斥體}

42 f:integer;

45 procedure TMyThread.Execute;

46 begin

47 { Place thread code here }

48 FreeOnTerminate:=True; {加上這句線程用完了會自動註釋}

49 Run; {運行}

50 end;

52 procedure TMyThread.Run;

53 var

54 i,y:integer;

55 begin

56 Inc(f);

57 y:=20*f;

58 for i := 0 to 2000 do

59 begin

60 if Mutex.WaitFor(INFINITE)=wrSignaled then {判斷函數，能用時就用}

61 begin

62 Form1.Canvas.Lock;

63 Form1.Canvas.TextOut(10,y,IntToStr(i));

64 Form1.Canvas.Unlock;

65 Sleep(1);

66 Mutex.Release; {釋放，誰來接下去用}

67 end;

68 end;

69 end;

71 procedure TForm1.btn1Click(Sender: TObject);

72 begin

73 f:=0;

74 Repaint;

75 Mutex:=TMutex.Create(False); {參數爲是否讓建立者擁有該互斥體，通常爲False}

76 MyThread:=TMyThread.Create(False);

77 MyThread:=TMyThread.Create(False);

78 MyThread:=TMyThread.Create(False);

79 end;

81 procedure TForm1.FormDestroy(Sender: TObject);

82 begin

83 Mutex.Free;{釋放互斥體}

84 end;

86 end.

Semaphore(信號或叫信號量)

{DELPHI2007不支持信號量，DELPHI2009纔開始支持}

1 unit Unit1;

3 interface

5 uses

6 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

7 Dialogs, StdCtrls;

9 type

10 TForm1 = class(TForm)

11 Button1: TButton;

12 Edit1: TEdit;

13 procedure Button1Click(Sender: TObject);

14 procedure FormCreate(Sender: TObject);

15 procedure FormDestroy(Sender: TObject);

16 procedure Edit1KeyPress(Sender: TObject; var Key: Char);

17 end;

19 var

20 Form1: TForm1;

22 implementation

24 {$R *.dfm}

26 uses SyncObjs;

27 var

28 f: Integer;

29 MySemaphore: TSemaphore;

31 function MyThreadFun(p: Pointer): DWORD; stdcall;

32 var

33 i,y: Integer;

34 begin

35 Inc(f);

36 y := 20 * f;

37 if MySemaphore.WaitFor(INFINITE) = wrSignaled then

38 begin

39 for i := 0 to 1000 do

40 begin

41 Form1.Canvas.Lock;

42 Form1.Canvas.TextOut(20, y, IntToStr(i));

43 Form1.Canvas.Unlock;

44 Sleep(1);

45 end;

46 end;

47 MySemaphore.Release;

48 Result := 0;

49 end;

51 procedure TForm1.Button1Click(Sender: TObject);

52 var

53 ThreadID: DWORD;

54 begin

55 if Assigned(MySemaphore) then MySemaphore.Free;

56 MySemaphore := TSemaphore.Create(nil, StrToInt(Edit1.Text), 5, ''); {建立，參數一爲安全默認爲nil，參數2能夠填寫運行多少線程，參數3是運行總數，參數4可命名用於多進程}

58 Self.Repaint;

59 f := 0;

60 CreateThread(nil, 0, @MyThreadFun, nil, 0, ThreadID);

61 CreateThread(nil, 0, @MyThreadFun, nil, 0, ThreadID);

62 CreateThread(nil, 0, @MyThreadFun, nil, 0, ThreadID);

63 CreateThread(nil, 0, @MyThreadFun, nil, 0, ThreadID);

64 CreateThread(nil, 0, @MyThreadFun, nil, 0, ThreadID);

65 end;

67 {讓 Edit 只接受 1 2 3 4 5 五個數}

68 procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);

69 begin

70 if not CharInSet(Key, ['1'..'5']) then Key := #0;

71 end;

73 procedure TForm1.FormCreate(Sender: TObject);

74 begin

75 Edit1.Text := '1';

76 end;

78 procedure TForm1.FormDestroy(Sender: TObject);

79 begin

80 if Assigned(MySemaphore) then MySemaphore.Free;

81 end;

83 end.

Event (事件對象)

注：相比API的處理方式，此類沒有啓動步進一次後暫停的方法。

1 unit Unit1;

3 interface

5 uses

6 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

7 Dialogs, StdCtrls;

9 type

10 TMyThread = class(TThread)

11 private

12 { Private declarations }

13 protected

14 procedure Execute; override;

15 procedure Run;

16 end;

18 TForm1 = class(TForm)

19 btn1: TButton;

20 btn2: TButton;

21 btn3: TButton;

22 btn4: TButton;

23 procedure btn1Click(Sender: TObject);

24 procedure FormDestroy(Sender: TObject);

25 procedure btn2Click(Sender: TObject);

26 procedure btn3Click(Sender: TObject);

27 procedure btn4Click(Sender: TObject);

28 procedure FormCreate(Sender: TObject);

29 private

30 { Private declarations }

31 public

32 { Public declarations }

33 end;

35 var

36 Form1: TForm1;

38 implementation

40 {$R *.dfm}

42 uses SyncObjs;

44 var

45 f:integer;

46 MyEvent:TEvent;

47 MyThread:TMyThread;

49 { TMyThread }

52 procedure TMyThread.Execute;

53 begin

54 inherited;

55 FreeOnTerminate:=True; {線程使用完本身註銷}

56 Run;

57 end;

59 procedure TMyThread.Run;

60 var

61 i,y:integer;

62 begin

63 Inc(f);

64 y:=20*f;

66 for i := 0 to 20000 do

67 begin

68 if MyEvent.WaitFor(INFINITE)=wrSignaled then {判斷事件在用沒，配合事件的啓動和暫停，對事件相關線程起統一控制}

69 begin

70 Form1.Canvas.lock;

71 Form1.Canvas.TextOut(10,y,IntToStr(i));

72 Form1.Canvas.Unlock;

73 Sleep(1);

74 end;

76 end;

78 end;

80 procedure TForm1.btn1Click(Sender: TObject);

81 begin

82 Repaint;

83 f:=0;

84 if Assigned(MyEvent) then MyEvent.Free; {若是有，就先銷燬}

86 {參數1安全設置，通常爲空；參數2爲True時可手動控制暫停，爲Flase時對象控制一次後當即暫停

87 參數3爲True時對象創建後便可運行，爲false時對象創建後控制爲暫停狀態，參數4爲對象名稱，用於跨進程，不用時默認''}

88 MyEvent:=TEvent.Create(nil,True,True,''); {建立事件}

90 end;

92 procedure TForm1.btn2Click(Sender: TObject);

93 var

94 ID:DWORD;

95 begin

96 MyThread:=TMyThread.Create(False); {建立線程}

97 end;

99 procedure TForm1.btn3Click(Sender: TObject);

100 begin

101 MyEvent.SetEvent; {啓動} {事件類沒有PulseEvent啓動一次後輕描談寫}

102 end;

103

104 procedure TForm1.btn4Click(Sender: TObject);

105 begin

106 MyEvent.ResetEvent; {暫停}

107 end;

108

109 procedure TForm1.FormCreate(Sender: TObject);

110 begin

111 btn1.Caption:='建立事件';

112 btn2.Caption:='建立線程';

113 btn3.Caption:='啓動';

114 btn4.Caption:='暫停';

115 end;

116

117 procedure TForm1.FormDestroy(Sender: TObject);

118 begin

119 MyEvent.Free; {釋放}

120 end;

121

122 end.

總結

多線程用TThread類以及Uses syncobjs後使用的 TCriticalSection (臨界區)，TMutex(互斥體)，TSemaphore (信號對象，D2009纔開始有)，TEvent (事件對象)不少都是引用了API的方法進行了必定的簡化，不過也有部分功能的缺失，如Event (事件對象)缺乏了啓動步進一次後暫停的功能，不過基本在同步上已經夠用了，另外在TThread類聲明的Execute過程裏，加上FreeOnTerminate := True;這句會讓線程執行完後自動釋放，還能夠把功能代碼的方法套在Synchronize()裏，用於同步一些非線程安全的控件對象，避免多個線程同時對一個對象操做引起的問題。

Delphi 線程同步技術

（轉）

上次跟你們分享了線程的標準代碼，其實在線程的使用中最重要的是線程的同步問題，若是你在使用線程後，發現你的界面常常被卡死，或者沒法顯示出來，顯示混亂，你的使用的變量值總是不按預想的變化，結果每每出乎意料，那麼你頗有多是忽略了線程同步的問題。

當有多個線程的時候，常常須要去同步這些線程以訪問同一個數據或資源。例如，假設有一個程序，其中一個線程用於把文件讀到內存，而另外一個線程用於統計文件中的字符數。固然，在把整個文件調入內存以前，統計它的計數是沒有意義的。可是，因爲每一個操做都有本身的線程，操做系統會把兩個線程看成是互不相干的任務分別執行，這樣就可能在沒有把整個文件裝入內存時統計字數。爲解決此問題，你必須使兩個線程同步工做。存在一些線程同步地址的問題，Windows 提供了許多線程同步的方式。在本節您將看到使用臨界區、互斥、信號量、事件、全局原子和Synchronize 函數來解決線程同步的問題。

下面的同步技術通常均有兩種使用方式，一種是直接使用Windows API 函數，一種是使用

由Delphi 對API 函數進行封裝的類。

如下函數以Delphi 2009 中的函數格式爲準。

1. Critical Sections 臨界區

臨界區是一種最直接的線程同步方式。所謂臨界區，就是一次只能由一個線程來執行的一段

代碼。例如把初始化數組的代碼放在臨界區內，另外一個線程在第一個線程處理完以前是不會

被執行的。臨界區很是適合於序列化對一個進程中的數據的訪問，由於它們的速度很快。

(1). 使用EnterCriticalSection( ) 和LeaveCriticalSection( ) API 函數

在使用臨界區以前，必須定義一個TRTLCriticalSection 類型的記錄變量並使用

InitializeCriticalSection( ) 過程來初始化臨界區。該過程多半在窗體建立時或在程序初始化時

執行。

其聲明以下：

procedure InitializeCriticalSection(var lpCriticalSection : TRTLCriticalSection);stdcall;

lpCriticalSection 參數是一個TRTLCriticalSection 類型的記錄，而且是變參。至於

TRTLCriticalSection 是如何定義的，這並不重要，由於不多須要查看這個記錄中的具體內容。

只須要在lpCriticalSection 中傳遞未初始化的記錄， InitializeCriticalSection( ) 過程就會填充這個記錄。

注意：Microsoft 故意隱瞞了TRTLCriticalSection 的細節。由於，其內容在不一樣的硬件平臺上是不一樣的。在基於Intel 的平臺上，TRTLCriticalSection 包含一個計數器、一個指示當前線程句柄的域和一個系統事件的句柄。在Alpha 平臺上，計數器被替換爲一種Alpha-CPU數據結構，稱爲spinlock 。

在記錄被填充後，咱們就能夠開始建立臨界區了。這時咱們須要用EnterCriticalSection( ) 和LeaveCriticalSection( ) 來封裝代碼塊，這兩個函數分別表明進入和離開臨界區，將要同步的代碼塊放在這兩個函數中間。在第一個線程調用了EnterCriticalSection( ) 以後，全部別的線程就不能再進入代碼塊並掛起等待第一個線程離開臨界區。下一個線程要等第一個線程調用LeaveCriticalSection( ) 後才能被喚醒。這兩個過程的聲明以下：

procedure EnterCriticalSection(var lpCriticalSection : TRTLCriticalSection);stdcall; //進入臨界區

procedure LeaveCriticalSection(var lpCriticalSection : TRTLCriticalSection);stdcall; //離開臨界

區

正如你所想的，參數lpCriticalSection 就是由InitializeCriticalSection( ) 填充的記錄。若是在某個子線程執行EnterCriticalSection( ) 前，已經有另外一個線程進入臨界區且還未離開臨界區，則該子線程將掛起並沒有限期等待另外一個線程離開臨界區，要想不掛起且0 時間等待，必須使用TryEnterCriticalSection( ) 。該過程聲明以下：

function TryEnterCriticalSection(var lpCriticalSection: TRTLCriticalSection): BOOL; stdcall;

TryEnterCriticalSection( ) 不一樣於EnterCriticalSection( ) 的聲明在於多出一個布爾型的返回值，若是返回True 表明成功進入臨界區，若是返回False 表明臨界區已佔用且不進入臨界區。運用這個函數，線程可以迅速查看它是否能夠訪問某個共享資源，若是不能訪問，那麼它能夠繼續執行某些其餘操做，而沒必要進行等待。

使用TryEnterCriticalSection( ) ，必須判斷其返回值。

當你不須要臨界區時，應當調用DeleteCriticalSection( ) 過程刪除臨界區，該函數多半在窗

體銷燬時或程序終止前執行。下面是它的聲明：

procedure DeleteCriticalSection(var lpCriticalSection : TRTLCriticalSection); stdcall;

例：

type

TMyThread = class(TThread)

protected

procedure Execute; override;

public

constructor Create; virtual;

end;

var

Form1 : TForm1;

CriticalSection : TRTLCriticalSection;//定義臨界區

implementation

{$R *.dfm}

var

tick: Integer = 1;

procedure TMyThread.Execute;

begin

EnterCriticalSection(CriticalSection);//進入臨界區

try

Form1.Edit1.Text := IntToStr(tick);

Inc(tick);

Sleep(10);

finally

LeaveCriticalSection(CriticalSection); //離開臨界區

end;

constructor TMyThread.Create;

begin

inherited Create(False);

FreeOnTerminate := True;

end;

procedure TForm1.RzButton1Click(Sender : TObject);

var

index: Integer;

begin

for index := 0 to 15 do

TMyThread.Create;

end;

procedure TForm1.FormCreate(Sender : TObject);

begin

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

end;

procedure TForm1.FormDestroy(Sender : TObject);

begin

DeleteCriticalSection(CriticalSection); //刪除臨界區

end;

(2). 使用TcriticalSection 類

TcriticalSection 是在SyncObjs 單元中定義的類，要使用它須要先uses SyncObjs 。它對上面的那些臨界區操做API 函數進行了封裝，簡化並方便了在Delphi 中的使用。例如TcriticalSection.Enter 實際上是調用了TRTLCriticalSection.Enter 。

使用TcriticalSection 類和通常類差很少，首先實例化TcriticalSection 類。使用的時候只要

在主線程當中建立這個臨界對象（注意必定要在須要同步的子線程以外創建這個對象）。

Tcriticalsection 類的構造函數比較簡單，沒有帶參數。

TcriticalSection.Enter 等效於EnterCriticalSection( ) 。

TcriticalSection.TryEnter 等效於TryEnterCriticalSection( ) 。

TcriticalSection.Leave 等效於LeaveCriticalSection( ) 。

例：

//在主線程中定義

var criticalsection : TCriticalsection;

criticalsection := TCriticalsection.Create;

…

//在子線程中使用

criticalsection.Enter;

try

...

finally

criticalsection.Leave;

end;

警告：臨界區只有在全部的線程都使用它來訪問全局內存時才起做用，若是有線程直接調用

內存，而不經過臨界區，也會形成同時訪問的問題。

注意：臨界區主要是爲實現線程之間同步的，可是使用的時候要注意，必定要在使用臨界區

同步的線程以外創建該臨界區（通常在主線程中定義臨界區並初始化臨界區）。臨界區是一

個進程裏的全部線程同步的最好辦法，它不是系統級的，只是進程級的，也就是說它可能利

用進程內的一些標誌來保證該進程內的線程同步，據Richter 說是一個記數循環。臨界區只

能在同一進程內使用。

2. Mutex 互斥

互斥是在序列化訪問資源時使用操做系統內核對象的一種方式。咱們首先設置一個互斥對

象，而後訪問資源，最後釋放互斥對象。在設置互斥時，若是另外一個線程（或進程）試圖設

置相同的互斥對象，該線程將會停下來，直到前一個線程（或進程）釋放該互斥對象爲止。

注意它能夠由不一樣應用程序共享。互斥的效果很是相似於臨界區，除了兩個關鍵的區別：首

先，互斥可用於跨進程的線程同步。其次，互斥對象能被賦予一個字符串名字，而且經過引

用此名字建立現有內核對象的附加句柄。線程同步使用臨界區，進程同步使用互斥。

當一個互斥對象再也不被一個線程所擁有，它就處於發信號狀態。此時首先調用

WaitForSingleObject( ) 函數(實現WaitFor 功能的API 還有幾個，這是最簡單的一個)的線

程就成爲該互斥對象的擁有者，將互斥對象設爲不發信號狀態。當線程調用ReleaseMutex( )

函數並傳遞一個互斥對象的句柄做爲參數時，這種擁有關係就被解除，互斥對象從新進入發

信號狀態。

提示：臨界區和互斥的做用相似，都是用來進行同步的，但它們間有如下一點差異。臨界區

只能在進程內使用，也就是說只能是進程內的線程間的同步；而互斥則還可用在進程之間的；

臨界區隨着進程的終止而終止，而互斥，若是你不用CloseHandle( ) 的話，在進程終止後

仍然在系統內存在，也就是說它是操做系統全局內核對象；臨界區與互斥最大的區別是在性

能上，臨界區在沒有線程衝突時，要用10 ~ 15 個時間片，而互斥因爲涉及到系統內核要用

400 ~ 600 個時間片；臨界區不是內核對象，它不禁操做系統的低級部件管理，並且不能使

用句柄來操縱，而互斥屬於操做系統內核對象。

(1). 使用CreateMutex( ) API 函數

調用函數CreateMutex( ) 來建立一個互斥。下面是函數的聲明：

function CreateMutex(lpMutexAttributes: PSecurityAttributes; bInitialOwner: BOOL; lpName:

PWideChar): THandle; stdcall;

lpMutexAttributes 參數爲一個指向TsecurityAttributtes 記錄的指針。此參數一般設爲nil ，

表示默認的安全屬性。bInitalOwner 參數表示建立互斥的線程是否要成爲此互斥對象的初始

擁有者，當此參數爲False 時，表示互斥對象沒有擁有者。lpName 參數指定互斥對象的名

稱，該名稱是大小寫區分的，設爲nil 表示無命名，若是參數不是設爲nil ，函數會搜索

是否有同名的互斥對象存在，若是有，函數就會返回同名互斥對象的句柄。不然，就新建立

一個互斥對象並返回其句柄。

當使用完互斥時，應當調用CloseHandle( ) 來關閉它。

WaitForSingleObject( ) 函數的使用：

在線程中使用WaitForSingleObject( ) 來防止其餘線程進入同步區域的代碼。第一個調用

WaitForSingleObject( ) 函數的線程會將事件對象(不限於互斥對象)設爲無信號狀態，其它線

程調用WaitForSingleObject( ) 函數時會檢查事件對象是否處於發信號狀態，這時狀態處於

無信號狀態，因此其它線程會掛起等待而不執行同步區域中的代碼。當第一個線程執行完同

步代碼後會釋放事件對象，事件對象從新進入發信號狀態並喚醒等待線程，其它線程會再次

將事件對象設爲無信號狀態，防止另外的線程執行同步代碼。這就實現了線程同步。

此函數聲明以下：

function WaitForSingleObject(hHandle : THandle; dwMilliseconds : DWORD): DWORD; stdcall;

這個函數能夠使當前線程在dwMilliseconds 參數指定的時間內等待事件對象信號，直到

hHandle 參數指定的事件對象進入發信號狀態爲止。當一個事件對象再也不被線程擁有時，它

就進入發信號狀態。當一個進程要終止時，它就進入發信號狀態。dwMilliseconds 參數設爲

0 ，這意味着只檢查hHandle 參數指定的事件對象是否處於發信號狀態，然後當即返回該

信號狀態。dwMilliseconds 參數設爲INFINITE ，表示若是信號不出現將一直等下去。

WaitForSingleObject( ) 在一個指定時間（dwMilliseconds）內等待一個事件對象變爲有信號，

在此時間內，若等待的事件對象一直是無信號的，則調用線程將處於掛起狀態，不然繼續執

行。超過此時間後，線程繼續運行。

WaitForSingleObject( ) 函數返回值及含義：

WAIT_ABANDONED 指定的對象是一個事件對象，該對象沒有被擁有線程在線程結束前釋

放。此時就稱事件對象被拋棄。互斥對象的全部權被贊成授予調用該函數的線程。互斥對象

被設置成爲無信號狀態

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

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

WAIT_FAILED 語句出錯

WaitForMultipleObjects( ) 函數的使用：

WaitForMultipleObjects( ) 與WaitForSingleObject( ) 相似，只是它要麼等待指定列表（由

lpHandles 指定）中若干個互斥對象（由nCount 決定）都變爲有信號，要麼等待一個列表

（由lpHandles 指定）中的一個對象變爲有信號（由bWaitAll 決定）。該函數聲明以下：

function WaitForMultipleObjects(nCount: DWORD; lpHandles: PWOHandleArray; bWaitAll:

BOOL; dwMilliseconds: DWORD): DWORD; stdcall;

nCount 參數表示句柄的數量，最大值爲MAXIMUM_WAIT_OBJECTS(64)，lpHandles 參數

是指向句柄數組的指針，lpHandles 類型能夠爲(Event，Mutex，Process，Thread，Semaphore)

數組，bWaitAll 參數表示等待的類型，若是爲True 則等待全部信號量有效再往下執行，設

爲False 則當有其中一個信號量有效時就向下執行，dwMilliseconds 參數表示超時時間，超

時後向下繼續執行。

注意：除WaitForSingleObject( ) 和WaitForMultipleObjects( ) 外，你還能夠使用

MsgWaitForMultipleObjects( ) 函數。該函數的詳細狀況請看Win32 API 聯機文檔。

WaitForSingleObject( ) 不只僅用於互斥，也用於信號量或事件，所以這裏用詞爲「事件對象」

而非互斥對象。在互斥例中，能夠用互斥對象代替事件對象，一樣，在信號量例中，也能以

信號量對象代替事件對象。

再次提示，當一個互斥對象再也不被一個線程所擁有，它就處於發信號狀態。此時首先調用

WaitForSingleObject( ) 函數的線程就成爲該互斥對象的擁有者，此互斥對象設爲無信號狀

態。當線程調用ReleaseMutex( ) 函數並傳遞一個互斥對象的句柄做爲參數時，這種擁有關

系就被解除，互斥對象從新進入發信號狀態。ReleaseMutex( ) 聲明以下：

function ReleaseMutex(hMutex: THandle): BOOL; stdcall;

進程間須要同步時，只須要執行CreateMutex( ) 創建一個互斥對象，須要同步的時候只需

要WaitForSingleObject(mutexhandle, INFINITE) ，釋放時只須要ReleaseMutex(mutexhandle)

便可。

例：

//先在主線程中建立互斥對象

var

hMutex : THandle = 0;//定義一個句柄

...

hMutex := CreateMutex(nil, False, nil);//建立互斥對象，並返回其句柄

//在子線程的Execute 方法中加入如下代碼

WaitForSingleObject(hMutex, INFINITE);//互斥對象處於發信號狀態時進入同步區，不然等待

...

ReleaseMutex(hMutex);

//最後記得要在主線程中釋放互斥對象

CloseHandle(hMutex);//關閉句柄

(2). 使用TMutex 類

TMutex 是在SyncObjs 單元中定義的類，其是ThandleObject 類的子類，要使用它須要先

uses SyncObjs 。它對上面的那些互斥操做API 函數進行了封裝，簡化並方便了在Delphi

中的使用。

使用前先實例化TMutex 類，其有多個重載的構造函數。聲明以下：

constructor Create(UseCOMWait: Boolean = False); overload;

constructor Create(MutexAttributes: PSecurityAttributes; InitialOwner: Boolean; const Name:

string; UseCOMWait: Boolean = False); overload;

constructor Create(DesiredAccess: LongWord; InheritHandle: Boolean; const Name: string;

UseCOMWait: Boolean = False); overload;

其實簡單的直接調用TMutex.Create 就能夠返回一個TMutex 對象。

第一個版本將建立一個無名的、使用默認安全屬性、建立其的線程非互斥對象的初始擁有者

的TMutex 對象，其中的參數UseCOMWait 設爲True 時表示當某個線程阻塞且等待互斥

對象時，任何單線程單元( STA ) COM 組件調用能夠發回到該線程，其默認爲False 。

第二個版本的MutexAttributes 參數一般設爲nil 表示使用默認的安全屬性。InitialOwner 參

數表示建立線程是不是互斥對象的初始擁有者。Name 參數表示互斥對象的名字，大小寫區

分。

第三個版本的DesiredAccess 參數表示訪問互斥的方式，若是傳遞的訪問方式沒有被容許那

麼構造函數會失敗，其參數能夠是下面幾個常量的任意組合：

MUTEX_ALL_ACCESS， MUTEX_MODIFY_STATE， SYNCHRONIZE， _DELETE，

READ_CONTROL ， WRITE_DAC ， WRITE_OWNER 。但任何組合必須包含

SYNCHRONIZE 訪問權。InheritHandle 參數表示子進程是否可繼承該互斥對象句柄。

TMutex.Acquire 等效於WaitForSingleObject(mutexhandle, INFINITE) ，其實際上就是執行

THandleObject.WaitFor(INFINITE)。

TMutex.Release 實際上就是執行ReleaseMutex(mutexhandle)。

TMutex.Acquire 只能無限期等待一個互斥對象，要設置等待時間或等待多個互斥對象要使

用TMutex.WaitFor( ) 或TMutex.WaitForMultiple( )。

WaitFor( ) 是定義在TMutex 的父類ThandleObject 中的虛函數，聲明以下：

function WaitFor(Timeout: LongWord): TWaitResult; virtual;

其中返回值枚舉型TWaitResult 能夠指示操做結果，wrSignaled 表明信號已set ，

wrTimeOut 表明超時且信號未set ，wrAbandoned 表明超時前事件對象被銷燬，wrError 代

表等待時出錯。

WaitForMultiple( ) 是定義在TMutex 的父類ThandleObject 中的類函數，聲明以下：

class function WaitForMultiple(const HandleObjs: THandleObjectArray; Timeout: LongWord;

AAll: Boolean; out SignaledObj: THandleObject; UseCOMWait: Boolean = False; Len: Integer =

0): TWaitResult;

其中HandleObjs 參數是包含了要等待的一系列事件對象的數組，AAll 參數設爲True 時，

當全部事件對象都進入發信號狀態後該函數調用纔會完成，當返回值爲wrSignaled 且

AAll 參數設爲False 時，第一個發信號的事件對象會被傳給SignaledObj 參數，Len 參數

設置監視事件對象的數量。

注意：WaitFor( ) 和WaitForMultiple( ) 均定義在ThandleObject 類中，而ThandleObject 類

是TMutex 、TSemaphore 、TEvent 類的父類，因此在描述WaitFor( ) 和WaitForMultiple( )

時使用的是事件對象而非互斥對象或信號量對象。

3. Semaphore 信號量

另外一種使線程同步的技術是使用信號量對象。它是在互斥的基礎上創建的，它與互斥類似，

但它能夠計數。信號量增長了資源計數的功能，預約數目的線程容許同時進入要同步的代碼。

例如能夠容許一個給定資源同時被三個線程訪問。其實互斥就是最大計數爲1 的信號量。

信號量的使用和互斥差很少。

(1). 使用CreateSemaphore( ) API 函數

能夠用CreateSemaphore( ) 來建立一個信號量對象，其聲明以下：

function CreateSemaphore(lpSemaphoreAttributes: PSecurityAttributes;

lInitialCount, lMaximumCount: Longint; lpName: PWideChar): THandle; stdcall;

和CreateMutex( ) 函數同樣， CreateSemaphore( ) 的第一個參數也是一個指向

TSecurityAttributes 記錄的指針，此參數的缺省值能夠設爲nil 。

lInitialCount 參數用來指定一個信號量的初始計數值，這個值必須在0 和lMaximumCount

之間。此參數大於0 ，就表示信號量處於發信號狀態。參數lMaximumCount 指定計數值

的最大值。若是這個信號量表明某種資源，那麼這個值表明可用資源總數。

參數lpName 用於給出信號量對象的名稱，它相似於CreateMutex( ) 函數的lpName 參數。

在程序中使用WaitForSingleObject( ) 來防止其餘線程進入同步區域的代碼。當調用

WaitForSingleObject( ) 函數( 或其餘WaitFor 函數) 時，此計數值就減1 。當調用

ReleaseSemaphore( ) 時，此計數值加1 ，此時同步區域代碼能夠被其它線程訪問。其聲明

以下：

function ReleaseSemaphore(hSemaphore: THandle; lReleaseCount: Longint;

lpPreviousCount: Pointer): BOOL; stdcall;

其中hSemaphore 參數是建立的信號量句柄，lReleaseCount 參數是釋放時要增長的信號量

計數，lpPreviousCount 參數是經過該指針參數來得到釋放前的信號量計數，若是不用設爲

nil 。

當使用完信號量時，應當調用CloseHandle( ) 來關閉它。

注意：通常的同步使用互斥，是由於其有一個特別之處，當一個持有互斥的線程DOWN 掉

的時候，互斥能夠自動讓其它等待這個對象的線程接受，而其它的內核對象則不具體這個功

能。之因此要使用信號量則是由於其能夠提供一個活動線程的上限，即lMaximumCount 參

數，這纔是它的真正有用之處。

例：

var

Form1 : TForm1;

HSem : THandle = 0;//定義一個信號量

implementation

var

tick : Integer = 0;

procedure TMyThread.Execute;

var

WaitReturn : DWord ;

begin

WaitReturn := WaitForSingleObject(HSem, INFINITE);//使用信號量對象，信號量減1

Form1.Edit1.Text := IntToStr(tick);

Inc(tick);

Sleep(10);

ReleaseSemaphore(HSem, 1, Nil);//釋放信號量對象，信號量加1

end;

…

procedure TForm1.FormCreate(Sender: TObject);

begin

HSem := CreateSemaphore(Nil, 1, 1, Nil);//建立信號量對象

end;

procedure TForm1.FormDestroy(Sender: TObject);

begin

CloseHandle(HSem);//銷燬信號量

end;

procedure TForm1.Button1Click(Sender: TObject);

var

index : Integer;

begin

for index := 0 to 10 do

TMyThread.Create;

end;

(2). 使用TSemaphore 類

TSemaphore 是在SyncObjs 單元中定義的類，其是ThandleObject 類的子類，要使用它需

要先uses SyncObjs 。它對上面的API 函數進行了封裝，簡化並方便了在Delphi 中的使

用。

其有三個版本的構造器，簡單執行TSemaphore.Create 就可實例化一個對象：

constructor Create(UseCOMWait: Boolean = False); overload;

constructor Create(SemaphoreAttributes: PSecurityAttributes; AInitialCount: Integer;

AMaximumCount: Integer; const Name: string; UseCOMWait: Boolean = False); overload;

constructor Create(DesiredAccess: LongWord; InheritHandle: Boolean;

const Name: string; UseCOMWait: Boolean = False); overload;

參數參見上面介紹。

TSemaphore.Acquire 等效於WaitForSingleObject(semaphorehandle, INFINITE) ，其實際上就

是執行THandleObject.WaitFor(INFINITE)。或者使用WaitFor( ) 和WaitForMultiple( ) 函數，

這兩個函數能夠設置等待的時間或等待多個事件對象。

TSemaphore.Release 有兩個版本，聲明以下：

procedure Release; override; overload;

function Release(AReleaseCount: Integer): Integer; overload; reintroduce;

第一個版本實際執行ReleaseSemaphore(FHandle, 1, nil)

第二個版本AReleaseCount 參數表示釋放時增長的信號量計數值，返回值是釋放前的信號

量計數值。實際執行ReleaseSemaphore(FHandle, AReleaseCount, @Result)，其中@Result 是

指向Release 函數返回值Integer 類型的指針。若是要指定增長計數值應使用第二個版本。

4. Event 事件

事件( Event )與Delphi 中的事件有所不一樣。從本質上說，Event 其實至關於一個全局的布

爾變量。它有兩個賦值操做： SetEvent 和ResetEvent ，至關於把它設置爲True 或False 。

而檢查它的值是經過WaitForSingleObject( ) (或其它WaitFor 函數)操做進行。SetEvent 和

ResetEvent 操做是原語操做，因此Event 能夠實現通常布爾變量不能實現的在多線程中的

應用。

當Event 從Reset 狀態向Set 狀態轉換時，喚醒其它掛起的線程，這就是它爲何叫

Event 的緣由。所謂「事件」就是指「狀態的轉換」。經過Event 能夠在線程間傳遞這種「狀

態轉換」信息。因此其本質是用來通知某事已經發生的信號，在這裏可用來表示共享資源已

經在使用或已經使用完的信號。

(1). 使用CreateEvent( ) API 函數

使用CreateEvent( ) 建立一個事件，聲明以下：

function CreateEvent(lpEventAttributes: PSecurityAttributes;

bManualReset, bInitialState: BOOL; lpName: PWideChar): THandle; stdcall;

其中bManualReset 參數表明建立的Event 是自動復位仍是人工復位，若是設爲True 表示

人工復位，一旦該Event 被設置爲有信號，則它一直會等到手動執行ResetEvent( ) 時纔會

變爲無信號，設爲False 表示自動復位，Event 被設置爲有信號時，則當有一個線程執行

WaitForSingleObject( ) 時該Event 就會自動復位，變成無信號。bInitialState 參數表明事件

的初始狀態，設爲True，事件建立後爲有信號，設爲False 則爲無信號。

不一樣於互斥或信號量，Event 不使用Release 相關函數設置相關對象進入發信號狀態，而使

用SetEvent( ) 函數，當線程執行完同步代碼要從同步區域中離開時應執行該函數，聲明如

下：

function SetEvent(hEvent: THandle): BOOL; stdcall;

當事件建立爲人工復位時，在線程進入同步區域執行同步代碼前應執行ResetEvent( ) 函數，

將Event 設爲無信號。聲明以下：

function ResetEvent(hEvent: THandle): BOOL; stdcall;

PulseEvent( ) 是一個比較有意思的方法，正如名字，它使一個Event 對象的狀態發生一次

脈衝變化，將無信號設爲有信號，喚醒等待的線程，再設爲無信號，而整個操做是原子的。

對自動復位的Event 對象，它僅喚醒第一個等到該事件的線程(若是有的話)，而對於人工復

位的Event 對象，它喚醒全部等待的線程。聲明以下：

function PulseEvent(hEvent: THandle): BOOL; stdcall;

當使用完事件時，應當調用CloseHandle( ) 來關閉它。

(2). 使用TEvent 類

TEvent 是在SyncObjs 單元中定義的類，其是ThandleObject 類的子類，要使用它須要先

uses SyncObjs 。它對上面的API 函數進行了封裝，簡化並方便了在Delphi 中的使用。

TEvent 若在多線程環境中可用於與其它線程同步；若在單線程環境中可用於調整響應不一樣

異步事件(如系統消息或用戶動做)的代碼段。構造函數以下：

constructor Create(EventAttributes: PSecurityAttributes; ManualReset: Boolean;

InitialState: Boolean; const Name: string; UseCOMWait: Boolean = False); overload;

constructor Create(UseCOMWait: Boolean = False); overload;

ManualReset 參數爲是否手工復位，InitialState 參數爲初始狀態。

TEvent.SetEvent( ) 和TEvent.ResetEvent( ) 均無參數。

TEvent 類中沒有定義與PulseEvent 功能同樣的方法。

TEvent 類一樣能夠使用WaitFor( ) 和WaitForMultiple( ) 函數。

但要注意的是，TEvent 類並無實現Acquire 函數，該函數是定義在TSynchroObject 類

中僅做爲接口、沒有執行代碼的虛函數。TSynchroObject 是ThandleObject 類的父類。其實

本身實現Acquire 函數也不難，它其實是執行THandleObject.WaitFor(INFINITE) 函數，

仿照上面的TMutex 類寫就能夠。

另外，Delphi 中定義了一個更簡單的事件類，TSimpleEvent 類，但從源代碼上看，該類僅

有TSimpleEvent = class(TEvent); 一句，並未定義任何屬於TSimpleEvent 的成員。估計是

做爲向後兼容而存在。

5. Global Atom 全局原子

Windows 系統中，爲了實現信息共享，系統維護了一張全局原子表( Global Atom Table )，

用於保存字符串與之對應的標誌符(原子)的組合，系統能保證其中的每一個原子都是惟一的，

管理其引用計數，而且當該全局原子的引用計數爲0 時，從內存中清除。應用程序在原子表

中能夠放置字符串，並接收一個16 位整數值(叫作原子，即Atom )，它能夠用來提取該字

符串。放在原子表中的字符串叫作原子的名字。系統提供了許多原子表。每一個表有不一樣的目

的。例如，動態數據交換( DDE )應用程序使用全局原子表與其餘應用程序共享項目名稱和

主題名稱字符串，不傳遞實際的字符串，一個DDE 應用程序傳遞全局原子給它的父進程，

父進程使用原子提取原子表中的字符串，這就是利用全局原子進行進程或線程間的數據交

換；使用全局原子也可防止屢次啓動某個程序。

應用程序能夠使用本地原子表來有效地管理大量只用於程序內部的字符串。這些字符串，以

及相關聯的原子，只對建立該原子表的應用程序可用。一個在許多數據結構中須要相同字符

串的應用程序，能夠經過使用本地原子表來減小內存使用。程序能夠把字符串放入原子表，

把相關的原子放入結構，而無需把字符串拷到每一個結構中。這樣，一個字符串在內存中只出

現一次，但能夠在程序中屢次使用。應用程序也能夠使用本地原子表來快速搜索特定的字符

串。要實現這樣的搜索，程序只需把要搜索的字符串放入原子表中，而後把結果原子與相關

數據結構中的原子相比較。一般狀況下，比較原子要比比較字符串要快得多。原子表是用哈

希表實現的。默認時，一個本地原子表使用37 個bucket 的哈希表。不過，你能夠經過調

用InitAtomTable 函數來改變bucket 數量。若是程序準備調用InitAtomTable ，那它必須

在調用任何其餘原子管理函數前調用它。這裏只簡單介紹本地原子表。它有多個相關的函數，

function InitAtomTable(nSize: DWORD): BOOL; stdcall;

function DeleteAtom(nAtom: ATOM): ATOM; stdcall;

function AddAtom(lpString: PWideChar): ATOM; stdcall;

function FindAtom(lpString: PWideChar): ATOM; stdcall;

function GetAtomName(nAtom: ATOM; lpBuffer: PWideChar; nSize: Integer): UINT; stdcall;

如下介紹全局原子表相關函數。

function GlobalAddAtom(lpString: PWideChar): ATOM; stdcall;

增長一個字符串到全局原子表中，並返回一個惟一標識值。

lpString 參數爲要添加到全局原子表中的字符串。

若是成功返回新增長的全局原子，失敗則返回0 。ATOM 類型等於Word 類型。

function GlobalDeleteAtom(nAtom: ATOM): ATOM; stdcall;

減小對指定全局原子的引用計數，引用計數減1 ，若是引用計數爲零，系統會在全局原子

表中刪除此原子。

此函數一直返回0 。

只要全局原子的引用計數大於0 ，其原子名稱將保留在全局原子表中，即便把它放入表中

的應用程序終結了。一個本地的原子表在應用程序終結時被銷燬，而無論其中原子的引用計

數是多少。

function GlobalFindAtom(lpString: PWideChar): ATOM; stdcall;

在全局原子表中查找是否存在指定字符串。

lpString 參數爲要查找的字符串。

若是在全局原子表中存在要查找的字符串，則返回此字符串對應的原子，沒有找到則返回0。

function GlobalGetAtomName(nAtom: ATOM;

lpBuffer: PWideChar; nSize: Integer): UINT; stdcall;

返回指定原子所對應的字符串。

nAtom 參數爲指定查找的原子，lpBuffer 參數爲要存放字符串的緩衝區，nSize 參數爲緩衝

區大小。

若操做成功返回緩衝區接受長度，若失敗返回0 。UINT 類型等於LongWord 類型。

例：

//在程序的program 文件中

...

if GlobalFindAtom(iAtom) = 0 then

begin

Application.Initialize;

Application.CreateForm(TForm1, Form1);

Application.Run;

end

else

MessageBox(0, '已經有一個程序在運行', ' ', mb_OK);

...

6. Synchronize 同步

Synchronize( ) 是定義在TThread 類中的函數，它可讓要執行的代碼實現線程同步，但這

種同步實際上是僞同步，其原理是將子線程要執行的代碼經過消息傳遞給主線程，由主線程來

執行，主線程將代碼放在一個隱蔽的窗口裏運行，而子線程會等待主線程將執行結果發給它，

這樣的話，這段代碼就不是子線程代碼，而是通常的主線程代碼。Synchronize( ) 只是將該

線程的代碼放到主線程中運行，並不是實際意義的線程同步。RAD Studio VCL Reference 中也

描述爲：Executes a method call within the main thread，Synchronize causes the call specified by

AMethod(參數) to be executed using the main thread,，thereby avoiding multi-thread conflicts。

這裏有一個問題，若是Synchronize( ) 執行的代碼很繁忙，例如執行的代碼運算過於複雜、

龐大或者從數據庫中取出大量數據，數據庫不會當即返回數據時或者使用ADO 組件鏈接

數據庫，而這時數據庫沒法鏈接，ADO 組件須要超時纔會終止運行，這些都會致使主窗口

會阻塞掉，看似死機通常。所以，一般對用戶界面類VCL 組件的訪問才使用Synchronize( )

函數，通常用戶界面類VCL 組件都由主線程建立、存在於主窗口中，並且對VCL 組件的

訪問或修改的執行效率都比較高，不會過多的影響性能。絕對不能在主線程中執行

Synchronize( ) 函數，這會致使無限循環。

Synchronize( ) 函數通常在線程的Execute 函數中調用。其有四個版本，兩個是類函數，兩

個是靜態函數，聲明以下：

class procedure Synchronize(AThread: TThread; AMethod: TThreadMethod); overload;

class procedure Synchronize(AThread: TThread; AThreadProc: TThreadProcedure); overload;

procedure Synchronize(AMethod: TThreadMethod); overload;

procedure Synchronize(AThreadProc: TThreadProcedure); overload;

AThread 參數是當前線程，TThreadMethod 是對象的函數指針類型，TThreadProcedure 是匿

名函數類型。

注意：Synchronize( ) 的AMethod 或AThreadProc 參數必須是一個無參數的procedure ，

故在此procedure 中沒法傳遞參數值，一般的解決方法是在線程類中增長額外的成員，用其

代替參數來傳遞信息。

例：

type

TMyThread = class(TThread)

str : string;//額外的域，代替參數將字符串寫入Memo

...

procedure TMyThread.WriteMemo;

begin

Memo.Lines.Add(str);

end;

...

procedure TMyThread.Execute;

begin

str := 'Hello';

synchronize(WriteMemo);

end;

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。