delphi 中几种多线程操作方式
在了解多線程之前我們先了解一下進(jìn)程和線程的關(guān)系
一個程序至少有一個主進(jìn)程,一個進(jìn)程至少有一個線程。
為了保證線程的安全性請大家看看下面介紹 Delphi多線程同步的一些處理方案大家可以參考:http://www.cr173.com/html/16747_1.html
主線程又程為UI線程。
進(jìn)程和線程的主要差別在于它們是不同的操作系統(tǒng)資源管理方式。進(jìn)程有獨立的地址空間，一個進(jìn)程崩潰后，在保護(hù)模式下不會對其它進(jìn)程產(chǎn)生影響，而線程只是一個進(jìn)程中的不同執(zhí)行路徑。線程有自己的堆棧和局部變量，但線程之間沒有單獨的地址空間，一個線程死掉就等于整個進(jìn)程死掉，所以多進(jìn)程的程序要比多線程的程序健壯，但在進(jìn)程切換時，耗費資源較大，效率要差一些。但對于一些要求同時進(jìn)行并且又要共享某些變量的并發(fā)操作，只能用線程，不能用進(jìn)程。如果有興趣深入的話，我建議你們看看《現(xiàn)代操作系統(tǒng)》或者《操作系統(tǒng)的設(shè)計與實現(xiàn)》。對就個問題說得比較清楚。
多線程應(yīng)該是編程工作者的基礎(chǔ)技能, 但這個基礎(chǔ)我從來沒學(xué)過，所以僅僅是看上去會一些，明白了2+2的時候，其實我還不知道1+1。
開始本應(yīng)該是一篇洋洋灑灑的文字, 不過我還是提倡先做起來, 在嘗試中去理解.
先試試這個:
procedureTForm1.Button1Click(Sender:TObject);
var
i:Integer;
begin
fori:=0to500000do
begin
Canvas.TextOut(10,10,IntToStr(i));
end;
end;
上面程序運行時, 我們的窗體基本是 "死" 的, 可以在你在程序運行期間拖動窗體試試...
Delphi 為我們提供了一個簡單的辦法(Application.ProcessMessages)來解決這個問題:
procedureTForm1.Button1Click(Sender:TObject);
var
i:Integer;
begin
fori:=0to500000do
begin
Canvas.TextOut(10,10,IntToStr(i));
Application.ProcessMessages;
end;
end;
這個 Application.ProcessMessages; 一般用在比較費時的循環(huán)中, 它會檢查并先處理消息隊列中的其他消息.
但這算不上多線程, 譬如: 運行中你拖動窗體, 循環(huán)會暫停下來...
在使用多線程以前, 讓我們先簡單修改一下程序:
functionMyFun:Integer;
var
i:Integer;
begin
fori:=0to500000do
begin
Form1.Canvas.Lock;
Form1.Canvas.TextOut(10,10,IntToStr(i));
Form1.Canvas.Unlock;
end;
Result:=0;
end;
procedureTForm1.Button1Click(Sender:TObject);
begin
MyFun;
end;
細(xì)數(shù)上面程序的變化:
1、首先這還不是多線程的, 也會讓窗體假 "死" 一會;
2、把執(zhí)行代碼寫在了一個函數(shù)里, 但這個函數(shù)不屬于 TForm1 的方法, 所以使用 Canvas 是必須冠以名稱(Form1);
3、既然是個函數(shù), (不管是否必要)都應(yīng)該有返回值;
4、使用了 500001 次 Lock 和 Unlock.
Canvas.Lock 好比在說: Canvas(繪圖表面)正忙著呢, 其他想用 Canvas 的等會;
Canvas.Unlock : 用完了, 解鎖!
在 Canvas 中使用 Lock 和 Unlock 是個好習(xí)慣, 在不使用多線程的情況下這無所謂, 但保不準(zhǔn)哪天程序會擴(kuò)展為多線程的; 我們現(xiàn)在學(xué)習(xí)多線程, 當(dāng)然應(yīng)該用.
在 Delphi 中使用多線程有兩種方法: 調(diào)用 API、使用 TThread 類; 使用 API 的代碼更簡單.
functionMyFun(p:Pointer):Integer;stdcall;
var
i:Integer;
begin
fori:=0to500000do
begin
Form1.Canvas.Lock;
Form1.Canvas.TextOut(10,10,IntToStr(i));
Form1.Canvas.Unlock;
end;
Result:=0;
end;
procedureTForm1.Button1Click(Sender:TObject);
var
ID:THandle;
begin
CreateThread(nil,0,@MyFun,nil,0,ID);
end;
代碼分析:
CreateThread 一個線程后, 算上原來的主線程, 這樣程序就有兩個線程、是標(biāo)準(zhǔn)的多線程了;
CreateThread 第三個參數(shù)是函數(shù)指針, 新線程建立后將立即執(zhí)行該函數(shù), 函數(shù)執(zhí)行完畢, 系統(tǒng)將銷毀此線程從而結(jié)束多線程的故事.
CreateThread 要使用的函數(shù)是系統(tǒng)級別的, 不能是某個類(譬如: TForm1)的方法, 并且有嚴(yán)格的格式(參數(shù)、返回值)要求, 不管你暫時是不是需要都必須按格式來;
因為是系統(tǒng)級調(diào)用, 還要綴上 stdcall, stdcall 是協(xié)調(diào)參數(shù)順序的, 雖然這里只有一個參數(shù)沒有順序可言, 但這是使用系統(tǒng)函數(shù)的慣例.
CreateThread 還需要一個 var 參數(shù)來接受新建線程的 ID, 盡管暫時沒用, 但這也是格式; 其他參數(shù)以后再說吧.
這樣一個最簡單的多線程程序就出來了, 咱們再用 TThread 類實現(xiàn)一次
type
TMyThread=class(TThread)
protected
procedureExecute;override;
end;
procedureTMyThread.Execute;
var
i:Integer;
begin
FreeOnTerminate:=True;{這可以讓線程執(zhí)行完畢后隨即釋放}
fori:=0to500000do
begin
Form1.Canvas.Lock;
Form1.Canvas.TextOut(10,10,IntToStr(i));
Form1.Canvas.Unlock;
end;
end;
procedureTForm1.Button1Click(Sender:TObject);
begin
TMyThread.Create(False);
end;
TThread 類有一個抽象方法(Execute), 因而是個抽象類, 抽象類只能繼承使用, 上面是繼承為 TMyThread.
繼承 TThread 主要就是實現(xiàn)抽象方法 Execute(把我們的代碼寫在里面), 等我們的 TMyThread 實例化后, 首先就會執(zhí)行 Execute 方法中的代碼.
按常規(guī)我們一般這樣去實例化:
procedureTForm1.Button1Click(Sender:TObject);
var
MyThread:TMyThread;
begin
MyThread:=TMyThread.Create(False);
end;
因為 MyThread 變量在這里毫無用處(并且編譯器還有提示), 所以不如直接寫做 TMyThread.Create(False);
我們還可以輕松解決一個問題, 如果: TMyThread.Create(True) ?
這樣線程建立后就不會立即調(diào)用 Execute, 可以在需要的時候再用 Resume 方法執(zhí)行線程, 譬如:
procedureTForm1.Button1Click(Sender:TObject);
var
MyThread:TMyThread;
begin
MyThread:=TMyThread.Create(True);
MyThread.Resume;
end;
//可簡化為:
procedureTForm1.Button1Click(Sender:TObject);
begin
withTMyThread.Create(True)doResume;
end;
一、入門
㈠、
functionCreateThread(
lpThreadAttributes:Pointer;{安全設(shè)置}
dwStackSize:DWORD;{堆棧大小}
lpStartAddress:TFNThreadStartRoutine;{入口函數(shù)}
lpParameter:Pointer;{函數(shù)參數(shù)}
dwCreationFlags:DWORD;{啟動選項}
varlpThreadId:DWORD{輸出線程ID}
):THandle;stdcall;{返回線程句柄}
在 Windows 上建立一個線程, 離不開 CreateThread 函數(shù);
TThread.Create 就是先調(diào)用了 BeginThread (Delphi 自定義的), BeginThread 又調(diào)用的 CreateThread.
既然有建立, 就該有釋放, CreateThread 對應(yīng)的釋放函數(shù)是: ExitThread, 譬如下面代碼:
procedureTForm1.Button1Click(Sender:TObject);
begin
ExitThread(0);{此句即可退出當(dāng)前程序,但不建議這樣使用}
end;
代碼注釋:
當(dāng)前程序是一個進(jìn)程, 進(jìn)程只是一個工作環(huán)境, 線程是工作者;
每個進(jìn)程都會有一個啟動線程(或叫主線程), 也就是說: 我們之前大量的編碼都是寫給這個主線程的;
上面的 ExitThread(0); 就是退出這個主線程;
系統(tǒng)不允許一個沒有線程的進(jìn)程存在, 所以程序就退出了.
另外: ExitThread 函數(shù)的參數(shù)是一個退出碼, 這個退出碼是給之后的其他函數(shù)用的, 這里隨便給個無符號整數(shù)即可.
或許你會說: 這個 ExitThread 挺好用的; 其實不管是用 API 還是用 TThread 類寫多線程, 我們很少用到它; 因為:
1、假如直接使用 API 的 CreateThread, 它執(zhí)行完入口函數(shù)后會自動退出, 無需 ExitThread;
2、用 TThread 類建立的線程又絕不能使用 ExitThread 退出; 因為使用 TThread 建立線程時會同時分配更多資源(譬如你自定義的成員、還有它的祖先類(TObject)分配的資源等等), 如果用 ExitThread 給草草退出了, 這些資源將得不到釋放而導(dǎo)致內(nèi)存泄露. 盡管 Delphi 提供了 EndThread(其內(nèi)部調(diào)用 ExitThread), 這也不需要我們手動操作(假如非要手動操作也是件很麻煩的事情, 因為很多時候你不知道線程是什么時候執(zhí)行完畢的).
除了 CreateThread, 還有一個 CreateRemoteThread, 可在其他進(jìn)程中建立線程, 這不應(yīng)該是現(xiàn)在學(xué)習(xí)的重點;
現(xiàn)在先集中精力把 CreateThread 的參數(shù)搞徹底.
倒著來吧, 先談?wù)?CreateThread 將要返回的 "線程句柄".
"句柄" 類似指針, 但通過指針可讀寫對象, 通過句柄只是使用對象;
有句柄的對象一般都是系統(tǒng)級別的對象(或叫內(nèi)核對象); 之所以給我們的是句柄而不是指針, 目的只有一個: "安全";
貌似通過句柄能做很多事情, 但一般把句柄提交到某個函數(shù)(一般是系統(tǒng)函數(shù))后, 我們也就到此為止很難了解更多了; 事實上是系統(tǒng)并不相信我們.
不管是指針還是句柄, 都不過是內(nèi)存中的一小塊數(shù)據(jù)(一般用結(jié)構(gòu)描述), 微軟并沒有公開句柄的結(jié)構(gòu)細(xì)節(jié), 猜一下它應(yīng)該包括: 真實的指針地址、訪問權(quán)限設(shè)置、引用計數(shù)等等.
既然 CreateThread 可以返回一個句柄, 說明線程屬于 "內(nèi)核對象".
實際上不管線程屬于哪個進(jìn)程, 它們在系統(tǒng)的懷抱中是平等的; 在優(yōu)先級(后面詳談)相同的情況下, 系統(tǒng)會在相同的時間間隔內(nèi)來運行一下每個線程, 不過這個間隔很小很小, 以至于讓我們誤以為程序是在不間斷地運行.
這時你應(yīng)該有一個疑問: 系統(tǒng)在去執(zhí)行其他線程的時候, 是怎么記住前一個線程的數(shù)據(jù)狀態(tài)的?
有這樣一個結(jié)構(gòu) TContext, 它基本上是一個 CPU 寄存器的集合, 線程是數(shù)據(jù)就是通過這個結(jié)構(gòu)切換的, 我們也可以通過 GetThreadContext 函數(shù)讀取寄存器看看.
附上這個結(jié)構(gòu) 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 的最后一個參數(shù)是 "線程的 ID";
既然可以返回句柄, 為什么還要輸出這個 ID? 現(xiàn)在我知道的是:
1、線程的 ID 是唯一的; 而句柄可能不只一個, 譬如可以用 GetCurrentThread 獲取一個偽句柄、可以用 DuplicateHandle 復(fù)制一個句柄等等.
2、ID 比句柄更輕便.
在主線程中 GetCurrentThreadId、MainThreadID、MainInstance 獲取的都是主線程的 ID.
㈡、啟動選項
functionCreateThread(
lpThreadAttributes:Pointer;
dwStackSize:DWORD;
lpStartAddress:TFNThreadStartRoutine;
lpParameter:Pointer;
dwCreationFlags:DWORD;{啟動選項}
varlpThreadId:DWORD
):THandle;stdcall;CreateThread 的倒數(shù)第二個參數(shù) dwCreationFlags(啟動選項) 有兩個可選值:
0: 線程建立后立即執(zhí)行入口函數(shù);
CREATE_SUSPENDED: 線程建立后會掛起等待.
可用 ResumeThread 函數(shù)是恢復(fù)線程的運行; 可用 SuspendThread 再次掛起線程.
這兩個函數(shù)的參數(shù)都是線程句柄, 返回值是執(zhí)行前的掛起計數(shù).
什么是掛起計數(shù)?
SuspendThread 會給這個數(shù) +1; ResumeThread 會給這個數(shù) -1; 但這個數(shù)最小是 0.
當(dāng)這個數(shù) = 0 時, 線程會運行; > 0 時會掛起.
如果被 SuspendThread 多次, 同樣需要 ResumeThread 多次才能恢復(fù)線程的運行.
在下面的例子中, 有新線程不斷給一個全局變量賦隨機值;
同時窗體上的 Timer 控件每隔 1/10 秒就把這個變量寫在窗體標(biāo)題;
在這個過程中演示了 ResumeThread、SuspendThread 兩個函數(shù).
//上面圖片中演示的代碼。
unitUnit1;
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;
procedureButton1Click(Sender:TObject);
procedureButton2Click(Sender:TObject);
procedureButton3Click(Sender:TObject);
procedureFormCreate(Sender:TObject);
procedureTimer1Timer(Sender:TObject);
end;
var
Form1:TForm1;
implementation
{$R*.dfm}
var
hThread:THandle;{線程句柄}
num:Integer;{全局變量,用于記錄隨機數(shù)}
{線程入口函數(shù)}
functionMyThreadFun(p:Pointer):Integer;stdcall;
begin
whileTruedo{假如線程不掛起,這個循環(huán)將一直循環(huán)下去}
begin
num:=Random(100);
end;
Result:=0;
end;
{建立并掛起線程}
procedureTForm1.Button1Click(Sender:TObject);
var
ID:DWORD;
begin
hThread:=CreateThread(nil,0,@MyThreadFun,nil,CREATE_SUSPENDED,ID);
Button1.Enabled:=False;
end;
{喚醒并繼續(xù)線程}
procedureTForm1.Button2Click(Sender:TObject);
begin
ResumeThread(hThread);
end;
{掛起線程}
procedureTForm1.Button3Click(Sender:TObject);
begin
SuspendThread(hThread);
end;
procedureTForm1.FormCreate(Sender:TObject);
begin
Timer1.Interval:=100;
end;
procedureTForm1.Timer1Timer(Sender:TObject);
begin
Text:=IntToStr(num);
end;
end.㈢、入口函數(shù)的參數(shù)
functionCreateThread(
lpThreadAttributes:Pointer;
dwStackSize:DWORD;
lpStartAddress:TFNThreadStartRoutine;
lpParameter:Pointer;{入口函數(shù)的參數(shù)}
dwCreationFlags:DWORD;
varlpThreadId:DWORD
):THandle;stdcall;線程入口函數(shù)的參數(shù)是個無類型指針(Pointer), 用它可以指定任何數(shù)據(jù); 本例是把鼠標(biāo)點擊窗體的坐標(biāo)傳遞給線程的入口函數(shù), 每次點擊窗體都會創(chuàng)建一個線程.
運行效果圖:
//上面演示的代碼
unitUnit1;
interface
uses
Windows,Messages,SysUtils,Variants,Classes,Graphics,Controls,Forms,
Dialogs;
type
TForm1=class(TForm)
procedureFormMouseUp(Sender:TObject;Button:TMouseButton;
Shift:TShiftState;X,Y:Integer);
end;
var
Form1:TForm1;
implementation
{$R*.dfm}
var
pt:TPoint;{這個坐標(biāo)點將會已指針的方式傳遞給線程,它應(yīng)該是全局的}
functionMyThreadFun(p:Pointer):Integer;stdcall;
var
i:Integer;
pt2:TPoint;{因為指針參數(shù)給的點隨時都在變,需用線程的局部變量存起來}
begin
pt2:=PPoint(p)^;{轉(zhuǎn)換}
fori:=0to1000000do
begin
withForm1.Canvasdobegin
Lock;
TextOut(pt2.X,pt2.Y,IntToStr(i));
Unlock;
end;
end;
Result:=0;
end;
procedureTForm1.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會自動轉(zhuǎn)換為Pointer的}
//CreateThread(nil,0,@MyThreadFun,Pointer(@pt),0,ID);
end;
end.這個例子還有不嚴(yán)謹(jǐn)?shù)牡胤? 當(dāng)一個線程 Lock 窗體的 Canvas 時, 其他線程在等待; 線程在等待時, 其中的計數(shù)也還在增加. 這也就是說: 現(xiàn)在并沒有去處理線程的同步; 同步是多線程中最重要的課題, 快到了.
另外有個小技巧: 線程函數(shù)的參數(shù)是個 32 位(4個字節(jié))的指針, 僅就本例來講, 可以讓它的 "高16位" 和 "低16位" 分別攜帶 X 和 Y; 這樣就不需要哪個全局的 pt 變量了.
其實在 Windows 的消息中就是這樣傳遞坐標(biāo)的, 在 Windows 的消息中一般高字節(jié)是 Y、低字節(jié)是 X; 咱們這么來吧, 這樣還可以使用給消息準(zhǔn)備的一些方便的函數(shù).
重寫本例代碼(當(dāng)然運行效果和窗體文件都是一樣的):
unitUnit1;
interface
uses
Windows,Messages,SysUtils,Variants,Classes,Graphics,Controls,Forms,
Dialogs;
type
TForm1=class(TForm)
procedureFormMouseUp(Sender:TObject;Button:TMouseButton;
Shift:TShiftState;X,Y:Integer);
end;
var
Form1:TForm1;
implementation
{$R*.dfm}
functionMyThreadFun(p:Pointer):Integer;stdcall;
var
i:Integer;
x,y:Word;
begin
x:=LoWord(Integer(p));
y:=HiWord(Integer(p));
{如果不使用LoWord、HiWord函數(shù)可以像下面這樣:}
//x:=Integer(p);
//y:=Integer(p)shr16;
fori:=0to1000000do
begin
withForm1.Canvasdobegin
Lock;
TextOut(x,y,IntToStr(i));
Unlock;
end;
end;
Result:=0;
end;
procedureTForm1.FormMouseUp(Sender:TObject;Button:TMouseButton;
Shift:TShiftState;X,Y:Integer);
var
ID:DWORD;
num:Integer;
begin
num:=MakeLong(X,Y);
{如果不使用MekeLong、MakeWParam、MakeLParam、MakeResult等函數(shù),可以像下面這樣:}
//num:=Yshl16+X;
CreateThread(nil,0,@MyThreadFun,Ptr(num),0,ID);
{上面的Ptr是專門將一個數(shù)字轉(zhuǎn)換為指針的函數(shù),當(dāng)然也可以這樣:}
//CreateThread(nil,0,@MyThreadFun,Pointer(num),0,ID);
end;
end.㈣、入口函數(shù)的指針
functionCreateThread(
lpThreadAttributes:Pointer;
dwStackSize:DWORD;
lpStartAddress:TFNThreadStartRoutine;{入口函數(shù)的指針}
lpParameter:Pointer;
dwCreationFlags:DWORD;
varlpThreadId:DWORD
):THandle;stdcall;到了入口函數(shù)了, 學(xué)到這個地方, 我查了一個入口函數(shù)的標(biāo)準(zhǔn)定義, 這個函數(shù)的標(biāo)準(zhǔn)返回值應(yīng)該是 DWORD, 不過這函數(shù)在 Delphi 的 System 單元定義的是: TThreadFunc = function(Parameter: Pointer): Integer; 我以后會盡量使用 DWORD 做入口函數(shù)的返回值.
這個返回值有什么用呢?
等線程退出后, 我們用 GetExitCodeThread 函數(shù)獲取的退出碼就是這個返回值!
如果線程沒有退出, GetExitCodeThread 獲取的退出碼將是一個常量 STILL_ACTIVE (259); 這樣我們就可以通過退出碼來判斷線程是否已退出.
還有一個問題: 前面也提到過, 線程函數(shù)不能是某個類的方法! 假如我們非要線程去執(zhí)行類中的一個方法能否實現(xiàn)呢?
盡管可以用 Addr(類名.方法名) 或 MethodAddress('published 區(qū)的方法名') 獲取類中方法的地址, 但都不能當(dāng)做線程的入口函數(shù), 原因可能是因為類中的方法的地址是在實例化為對象時動態(tài)分配的.
后來換了個思路, 其實很簡單: 在線程函數(shù)中再調(diào)用方法不就得了, 估計 TThread 也應(yīng)該是這樣.
下面的例子就嘗試了用線程調(diào)用 TForm1 類中的方法, 并測試了退出碼的相關(guān)問題.
unitUnit1;
interface
uses
Windows,Messages,SysUtils,Variants,Classes,Graphics,Controls,Forms,
Dialogs,StdCtrls;
type
TForm1=class(TForm)
Button1:TButton;
Button2:TButton;
procedureButton1Click(Sender:TObject);
procedureButton2Click(Sender:TObject);
private
procedureFormProc;{準(zhǔn)備給線程使用的方法}
end;
var
Form1:TForm1;
implementation
{$R*.dfm}
var
hThread:THandle;
{線程入口函數(shù)}
functionMyThreadFun(p:Pointer):DWORD;stdcall;
begin
Form1.FormProc;{調(diào)用TForm1類的方法}
Result:=99;{這個返回值將成為線程的退出代碼,99是我隨意給的數(shù)字}
end;
{TForm1的方法,本例中是給線程的入口函數(shù)調(diào)用的}
procedureTForm1.FormProc;
var
i:Integer;
begin
fori:=0to200000do
begin
withForm1.Canvasdobegin
Lock;
TextOut(10,10,IntToStr(i));
Unlock;
end;
end;
end;
{建立并執(zhí)行線程}
procedureTForm1.Button1Click(Sender:TObject);
var
ID:DWORD;
begin
hThread:=CreateThread(nil,0,@MyThreadFun,nil,0,ID);
end;
{獲取線程的退出代碼,并判斷線程是否退出}
procedureTForm1.Button2Click(Sender:TObject);
var
ExitCode:DWORD;
begin
GetExitCodeThread(hThread,ExitCode);
ifhThread=0then
begin
Text:='線程還未啟動';
Exit;
end;
ifExitCode=STILL_ACTIVEthen
Text:=Format('線程退出代碼是:%d,表示線程還未退出',[ExitCode])
else
Text:=Format('線程已退出,退出代碼是:%d',[ExitCode]);
end;
end.㈤、堆棧大小
functionCreateThread(
lpThreadAttributes:Pointer;
dwStackSize:DWORD;{堆棧大小}
lpStartAddress:TFNThreadStartRoutine;
lpParameter:Pointer;
dwCreationFlags:DWORD;
varlpThreadId:DWORD
):THandle;stdcall;CreateThread 的第二個參數(shù)是分配給線程的堆棧大小.
這首先這可以讓我們知道: 每個線程都有自己獨立的堆棧(也擁有自己的消息隊列).
什么是堆棧? 其實堆是堆、棧是棧, 有時 "棧" 也被叫做 "堆棧".
它們都是進(jìn)程中的內(nèi)存區(qū)域, 主要是存取方式不同(棧:先進(jìn)后出; 堆:先進(jìn)先出);
"棧"(或叫堆棧)適合存取臨時而輕便的變量, 主要用來儲存局部變量; 譬如 for i := 0 to 99 do 中的 i 就只能存于棧中, 你把一個全局的變量用于 for 循環(huán)計數(shù)是不可以的.
現(xiàn)在我們知道了線程有自己的 "棧", 并且在建立線程時可以分配棧的大小.
前面所有的例子中, 這個值都是 0, 這表示使用系統(tǒng)默認(rèn)的大小, 默認(rèn)和主線程棧的大小一樣, 如果不夠用會自動增長;
那主線程的棧有多大? 這個值是可以設(shè)定的: Project -> Options -> linker -> memory size(如圖)
棧是私有的但堆是公用的, 如果不同的線程都來使用一個全局變量有點亂套;
為解決這個問題 Delphi 為我們提供了一個類似 var 的 ThreadVar 關(guān)鍵字, 線程在使用 ThreadVar 聲明的全局變量時會在各自的棧中留一個副本, 這樣就解決了沖突. 不過還是盡量使用局部變量, 或者在繼承 TThread 時使用類的成員變量, 因為 ThreadVar 的效率不好, 據(jù)說比局部變量能慢 10 倍.
在下面的例子就測試了用 var 和 ThreadVar 定義變量的不同.
使用 var 效果圖:
使用 ThreadVar 效果圖:
unitUnit1;
interface
uses
Windows,Messages,SysUtils,Variants,Classes,Graphics,Controls,Forms,
Dialogs,StdCtrls;
type
TForm1=class(TForm)
Button1:TButton;
procedureButton1Click(Sender:TObject);
end;
var
Form1:TForm1;
implementation
{$R*.dfm}
//varnum:Integer;{全局變量}
threadvarnum:Integer;{支持多線程的全局變量}
functionMyThreadFun(p:Pointer):DWORD;stdcall;
var
py:Integer;
begin
py:=Integer(p);
whileTruedo
begin
Inc(num);
withForm1.Canvasdobegin
Lock;
TextOut(20,py,IntToStr(num));
Unlock;
end;
Sleep(1000);{然線程掛起1秒鐘再繼續(xù)}
end;
end;
procedureTForm1.Button1Click(Sender:TObject);
var
ID:DWORD;
begin
{借入口函數(shù)的參數(shù)傳遞了一個坐標(biāo)點中的Y值,以讓各線程把結(jié)果輸出在不同位置}
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.㈥、安全設(shè)置
functionCreateThread(
lpThreadAttributes:Pointer;{安全設(shè)置}
dwStackSize:DWORD;
lpStartAddress:TFNThreadStartRoutine;
lpParameter:Pointer;
dwCreationFlags:DWORD;
varlpThreadId:DWORD
):THandle;stdcall;CreateThread 的第一個參數(shù) lpThreadAttributes 是指向 TSecurityAttributes 結(jié)構(gòu)的指針, 一般都是置為 nil, 這表示沒有訪問限制; 該結(jié)構(gòu)的定義是:
//TSecurityAttributes(又名:SECURITY_ATTRIBUTES、_SECURITY_ATTRIBUTES)
_SECURITY_ATTRIBUTES=record
nLength:DWORD;{結(jié)構(gòu)大小}
lpSecurityDescriptor:Pointer;{默認(rèn)nil;這是另一個結(jié)構(gòu)TSecurityDescriptor的指針}
bInheritHandle:BOOL;{默認(rèn)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;夠復(fù)雜的, 但我們在多線程編程時不需要去設(shè)置它們, 大都是使用默認(rèn)設(shè)置(也就是賦值為 nil).
我覺得有必要在此刻了解的是: 建立系統(tǒng)內(nèi)核對象時一般都有這個屬性(TSecurityAttributes);
在接下來多線程的課題中要使用一些內(nèi)核對象, 不如先盤點一下, 到時碰到這個屬性時給個 nil 即可, 不必再費神.
{建立事件}
functionCreateEvent(
lpEventAttributes:PSecurityAttributes;{!}
bManualReset:BOOL;
bInitialState:BOOL;
lpName:PWideChar
):THandle;stdcall;
{建立互斥}
functionCreateMutex(
lpMutexAttributes:PSecurityAttributes;{!}
bInitialOwner:BOOL;
lpName:PWideChar
):THandle;stdcall;
{建立信號}
functionCreateSemaphore(
lpSemaphoreAttributes:PSecurityAttributes;{!}
lInitialCount:Longint;
lMaximumCount:Longint;
lpName:PWideChar
):THandle;stdcall;
{建立等待計時器}
functionCreateWaitableTimer(
lpTimerAttributes:PSecurityAttributes;{!}
bManualReset:BOOL;
lpTimerName:PWideChar
):THandle;stdcall;
上面的四個系統(tǒng)內(nèi)核對象(事件、互斥、信號、計時器)都是線程同步的手段, 從這也能看出處理線程同步的復(fù)雜性; 不過這還不是全部, Windows Vista 開始又增加了 Condition variables(條件變量)、Slim Reader-Writer Locks(讀寫鎖)等同步手段.
不過最簡單、最輕便(速度最快)的同步手段還是 CriticalSection(臨界區(qū)), 但它不屬于系統(tǒng)內(nèi)核對象, 當(dāng)然也就沒有句柄、沒有 TSecurityAttributes 這個安全屬性, 這也導(dǎo)致它不能跨進(jìn)程使用; 不過寫多線程時一般不用跨進(jìn)程, 所以 CriticalSection 應(yīng)該是最常用的同步手段.
二、臨界區(qū)。
先看一段程序, 代碼文件:
unitUnit1;
interface
uses
Windows,Messages,SysUtils,Variants,Classes,Graphics,Controls,Forms,
Dialogs,StdCtrls;
type
TForm1=class(TForm)
ListBox1:TListBox;
Button1:TButton;
procedureFormCreate(Sender:TObject);
procedureButton1Click(Sender:TObject);
end;
var
Form1:TForm1;
implementation
{$R*.dfm}
functionMyThreadFun(p:Pointer):DWORD;stdcall;
var
i:Integer;
begin
fori:=0to99doForm1.ListBox1.Items.Add(IntToStr(i));
Result:=0;
end;
procedureTForm1.Button1Click(Sender:TObject);
var
ID:DWORD;
begin
CreateThread(nil,0,@MyThreadFun,nil,0,ID);
CreateThread(nil,0,@MyThreadFun,nil,0,ID);
CreateThread(nil,0,@MyThreadFun,nil,0,ID);
end;
procedureTForm1.FormCreate(Sender:TObject);
begin
ListBox1.Align:=alLeft;
end;
end.在這段程序中, 有三個線程幾乎是同時建立, 向窗體中的 ListBox1 中寫數(shù)據(jù), 最后寫出的結(jié)果是這樣的:
能不能讓它們別打架, 一個完了另一個再來? 這就要用到多線程的同步技術(shù).
前面說過, 最簡單的同步手段就是 "臨界區(qū)".
先說這個 "同步"(Synchronize), 首先這個名字起的不好, 我們好像需要的是 "異步"; 其實異步也不準(zhǔn)確...
管它叫什么名字呢, 它的目的就是保證不沖突、有次序、都發(fā)生.
"臨界區(qū)"(CriticalSection): 當(dāng)把一段代碼放入一個臨界區(qū), 線程執(zhí)行到臨界區(qū)時就獨占了, 讓其他也要執(zhí)行此代碼的線程先等等; 這和前面用的 Lock 和 UnLock 差不多; 使用格式如下:
varCS:TRTLCriticalSection;{聲明一個TRTLCriticalSection結(jié)構(gòu)類型變量;它應(yīng)該是全局的}
InitializeCriticalSection(CS);{初始化}
EnterCriticalSection(CS);{開始:輪到我了其他線程走開}
LeaveCriticalSection(CS);{結(jié)束:其他線程可以來了}
DeleteCriticalSection(CS);{刪除:注意不能過早刪除}
//也可用TryEnterCriticalSection替代EnterCriticalSection.用上臨界區(qū), 重寫上面的代碼, 運行效果圖:
//用臨界區(qū)重寫后的代碼文件:
unitUnit1;
interface
uses
Windows,Messages,SysUtils,Variants,Classes,Graphics,Controls,Forms,
Dialogs,StdCtrls;
type
TForm1=class(TForm)
ListBox1:TListBox;
Button1:TButton;
procedureFormCreate(Sender:TObject);
procedureFormDestroy(Sender:TObject);
procedureButton1Click(Sender:TObject);
end;
var
Form1:TForm1;
implementation
{$R*.dfm}
var
CS:TRTLCriticalSection;
functionMyThreadFun(p:Pointer):DWORD;stdcall;
var
i:Integer;
begin
EnterCriticalSection(CS);
fori:=0to99doForm1.ListBox1.Items.Add(IntToStr(i));
LeaveCriticalSection(CS);
Result:=0;
end;
procedureTForm1.Button1Click(Sender:TObject);
var
ID:DWORD;
begin
CreateThread(nil,0,@MyThreadFun,nil,0,ID);
CreateThread(nil,0,@MyThreadFun,nil,0,ID);
CreateThread(nil,0,@MyThreadFun,nil,0,ID);
end;
procedureTForm1.FormCreate(Sender:TObject);
begin
ListBox1.Align:=alLeft;
InitializeCriticalSection(CS);
end;
procedureTForm1.FormDestroy(Sender:TObject);
begin
DeleteCriticalSection(CS);
end;
end.Delphi 在 SyncObjs 單元給封裝了一個 TCriticalSection 類, 用法差不多, 代碼如下:
unitUnit1;
interface
uses
Windows,Messages,SysUtils,Variants,Classes,Graphics,Controls,Forms,
Dialogs,StdCtrls;
type
TForm1=class(TForm)
ListBox1:TListBox;
Button1:TButton;
procedureFormCreate(Sender:TObject);
procedureFormDestroy(Sender:TObject);
procedureButton1Click(Sender:TObject);
end;
var
Form1:TForm1;
implementation
{$R*.dfm}
usesSyncObjs;
var
CS:TCriticalSection;
functionMyThreadFun(p:Pointer):DWORD;stdcall;
var
i:Integer;
begin
CS.Enter;
fori:=0to99doForm1.ListBox1.Items.Add(IntToStr(i));
CS.Leave;
Result:=0;
end;
procedureTForm1.Button1Click(Sender:TObject);
var
ID:DWORD;
begin
CreateThread(nil,0,@MyThreadFun,nil,0,ID);
CreateThread(nil,0,@MyThreadFun,nil,0,ID);
CreateThread(nil,0,@MyThreadFun,nil,0,ID);
end;
procedureTForm1.FormCreate(Sender:TObject);
begin
ListBox1.Align:=alLeft;
CS:=TCriticalSection.Create;
end;
procedureTForm1.FormDestroy(Sender:TObject);
begin
CS.Free;
end;
end.三、等待函數(shù) WaitForSingleObject
一下子跳到等待函數(shù) WaitForSingleObject, 是因為下面的 Mutex、Semaphore、Event、WaitableTimer 等同步手段都要使用這個函數(shù); 不過等待函數(shù)可不止 WaitForSingleObject 它一個, 但它最簡單.
functionWaitForSingleObject(
hHandle:THandle;{要等待的對象句柄}
dwMilliseconds:DWORD{等待的時間,單位是毫秒}
):DWORD;stdcall;{返回值如下:}
WAIT_OBJECT_0{等著了,本例中是:等的那個進(jìn)程終于結(jié)束了}
WAIT_TIMEOUT{等過了點(你指定的時間),也沒等著}
WAIT_ABANDONED{好不容易等著了,但人家還是不讓咱執(zhí)行;這一般是互斥對象}
//WaitForSingleObject的第二個參數(shù)一般給常數(shù)值INFINITE,表示一直等下去,死等.
WaitForSingleObject 等待什么? 在多線程里就是等待另一個線程的結(jié)束, 快來執(zhí)行自己的代碼; 不過它可以等待的對象可不止線程; 這里先來一個等待另一個進(jìn)程結(jié)束的例子, 運行效果圖:
//WaitForSingleObject的示例代碼文件:
unitUnit1;
interface
uses
Windows,Messages,SysUtils,Variants,Classes,Graphics,Controls,Forms,
Dialogs,StdCtrls;
type
TForm1=class(TForm)
Button1:TButton;
procedureButton1Click(Sender:TObject);
end;
var
Form1:TForm1;
implementation
{$R*.dfm}
var
hProcess:THandle;{進(jìn)程句柄}
{等待一個指定句柄的進(jìn)程什么時候結(jié)束}
functionMyThreadFun(p:Pointer):DWORD;stdcall;
begin
ifWaitForSingleObject(hProcess,INFINITE)=WAIT_OBJECT_0then
Form1.Text:=Format('進(jìn)程%d已關(guān)閉',[hProcess]);
Result:=0;
end;
{啟動一個進(jìn)程,并建立新線程等待它的結(jié)束}
procedureTForm1.Button1Click(Sender:TObject);
var
pInfo:TProcessInformation;
sInfo:TStartupInfo;
Path:array[0..MAX_PATH-1]ofChar;
ThreadID:DWORD;
begin
{先獲取記事本的路徑}
GetSystemDirectory(Path,MAX_PATH);
StrCat(Path,'
otepad.exe');
{用CreateProcess打開記事本并獲取其進(jìn)程句柄,然后建立線程監(jiān)視}
FillChar(sInfo,SizeOf(sInfo),0);
ifCreateProcess(Path,nil,nil,nil,False,0,nil,nil,sInfo,pInfo)then
begin
hProcess:=pInfo.hProcess;{獲取進(jìn)程句柄}
Text:=Format('進(jìn)程%d已啟動',[hProcess]);
CreateThread(nil,0,@MyThreadFun,nil,0,ThreadID);{建立線程監(jiān)視}
end;
end;
end.總結(jié)
以上是生活随笔為你收集整理的delphi 中几种多线程操作方式的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： dubbo-admin构建报错
- 下一篇： 【BZOJ】2395: [Balkan