delphi 中幾種多線程操作方式

在了解多線程之前我們先了解一下進(jìn)程和線程的關(guān)系

一個(gè)程序至少有一個(gè)主進(jìn)程,一個(gè)進(jìn)程至少有一個(gè)線程。

為了保證線程的安全性請(qǐng)大家看看下面介紹 DELPHI多線程同步的一些處理方案大家可以參考:http://www.ksks6.com/html/16747_1.html

主線程又程為UI線程。

進(jìn)程和線程的主要差別在于它們是不同的操作系統(tǒng)資源管理方式。進(jìn)程有獨(dú)立的地址空間，一個(gè)進(jìn)程崩潰后，在保護(hù)模式下不會(huì)對(duì)其它進(jìn)程產(chǎn)生影響，而線程只是一個(gè)進(jìn)程中的不同執(zhí)行路徑。線程有自己的堆棧和局部變量，但線程之間沒有單獨(dú)的地址空間，一個(gè)線程死掉就等于整個(gè)進(jìn)程死掉，所以多進(jìn)程的程序要比多線程的程序健壯，但在進(jìn)程切換時(shí)，耗費(fèi)資源較大，效率要差一些。但對(duì)于一些要求同時(shí)進(jìn)行并且又要共享某些變量的并發(fā)操作，只能用線程，不能用進(jìn)程。如果有興趣深入的話，我建議你們看看《現(xiàn)代操作系統(tǒng)》或者《操作系統(tǒng)的設(shè)計(jì)與實(shí)現(xiàn)》。對(duì)就個(gè)問題說得比較清楚。

多線程應(yīng)該是編程工作者的基礎(chǔ)技能, 但這個(gè)基礎(chǔ)我從來沒學(xué)過，所以僅僅是看上去會(huì)一些，明白了2+2的時(shí)候，其實(shí)我還不知道1+1。

開始本應(yīng)該是一篇洋洋灑灑的文字, 不過我還是提倡先做起來, 在嘗試中去理解.

先試試這個(gè):

procedure TForm1.Button1Click(Sender: TObject); 
var 
  i: Integer; 
begin 
  for i := 0 to 500000 do 
  begin 
    Canvas.TextOut(10, 10, IntToStr(i)); 
  end; 
end;

上面程序運(yùn)行時(shí), 我們的窗體基本是 "死" 的, 可以在你在程序運(yùn)行期間拖動(dòng)窗體試試...

Delphi 為我們提供了一個(gè)簡(jiǎn)單的辦法(Application.ProcessMessages)來解決這個(gè)問題:

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; 
end;

這個(gè) Application.ProcessMessages; 一般用在比較費(fèi)時(shí)的循環(huán)中, 它會(huì)檢查并先處理消息隊(duì)列中的其他消息.

但這算不上多線程, 譬如: 運(yùn)行中你拖動(dòng)窗體, 循環(huán)會(huì)暫停下來...

在使用多線程以前, 讓我們先簡(jiǎn)單修改一下程序:

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;

細(xì)數(shù)上面程序的變化:
1、首先這還不是多線程的, 也會(huì)讓窗體假 "死" 一會(huì);
2、把執(zhí)行代碼寫在了一個(gè)函數(shù)里, 但這個(gè)函數(shù)不屬于 TForm1 的方法, 所以使用 Canvas 是必須冠以名稱(Form1);
3、既然是個(gè)函數(shù), (不管是否必要)都應(yīng)該有返回值;
4、使用了 500001 次 Lock 和 Unlock.

Canvas.Lock 好比在說: Canvas(繪圖表面)正忙著呢, 其他想用 Canvas 的等會(huì);
Canvas.Unlock : 用完了, 解鎖!

在 Canvas 中使用 Lock 和 Unlock 是個(gè)好習(xí)慣, 在不使用多線程的情況下這無所謂, 但保不準(zhǔn)哪天程序會(huì)擴(kuò)展為多線程的; 我們現(xiàn)在學(xué)習(xí)多線程, 當(dāng)然應(yīng)該用.

在 Delphi 中使用多線程有兩種方法: 調(diào)用 API、使用 TThread 類; 使用 API 的代碼更簡(jiǎn)單.

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 一個(gè)線程后, 算上原來的主線程, 這樣程序就有兩個(gè)線程、是標(biāo)準(zhǔn)的多線程了;
CreateThread 第三個(gè)參數(shù)是函數(shù)指針, 新線程建立后將立即執(zhí)行該函數(shù), 函數(shù)執(zhí)行完畢, 系統(tǒng)將銷毀此線程從而結(jié)束多線程的故事.

CreateThread 要使用的函數(shù)是系統(tǒng)級(jí)別的, 不能是某個(gè)類(譬如: TForm1)的方法, 并且有嚴(yán)格的格式(參數(shù)、返回值)要求, 不管你暫時(shí)是不是需要都必須按格式來;
因?yàn)槭窍到y(tǒng)級(jí)調(diào)用, 還要綴上 stdcall, stdcall 是協(xié)調(diào)參數(shù)順序的, 雖然這里只有一個(gè)參數(shù)沒有順序可言, 但這是使用系統(tǒng)函數(shù)的慣例.

CreateThread 還需要一個(gè) var 參數(shù)來接受新建線程的 ID, 盡管暫時(shí)沒用, 但這也是格式; 其他參數(shù)以后再說吧.

這樣一個(gè)最簡(jiǎn)單的多線程程序就出來了, 咱們?cè)儆?TThread 類實(shí)現(xiàn)一次

type 
  TMyThread = class(TThread) 
  protected 
    procedure Execute; override; 
  end; 
 
procedure TMyThread.Execute; 
var 
  i: Integer; 
begin 
  FreeOnTerminate := True; {這可以讓線程執(zhí)行完畢后隨即釋放} 
  for i := 0 to 500000 do 
  begin 
    Form1.Canvas.Lock; 
    Form1.Canvas.TextOut(10, 10, IntToStr(i)); 
    Form1.Canvas.Unlock; 
  end; 
end; 
 
procedure TForm1.Button1Click(Sender: TObject); 
begin 
  TMyThread.Create(False); 
end;

TThread 類有一個(gè)抽象方法(Execute), 因而是個(gè)抽象類, 抽象類只能繼承使用, 上面是繼承為 TMyThread.

繼承 TThread 主要就是實(shí)現(xiàn)抽象方法 Execute(把我們的代碼寫在里面), 等我們的 TMyThread 實(shí)例化后, 首先就會(huì)執(zhí)行 Execute 方法中的代碼.

按常規(guī)我們一般這樣去實(shí)例化:

procedure TForm1.Button1Click(Sender: TObject); 
var 
  MyThread: TMyThread; 
begin 
  MyThread := TMyThread.Create(False); 
end;

因?yàn)?MyThread 變量在這里毫無用處(并且編譯器還有提示), 所以不如直接寫做 TMyThread.Create(False);

我們還可以輕松解決一個(gè)問題, 如果: TMyThread.Create(True) ?
這樣線程建立后就不會(huì)立即調(diào)用 Execute, 可以在需要的時(shí)候再用 Resume 方法執(zhí)行線程, 譬如:

procedure TForm1.Button1Click(Sender: TObject); 
var 
  MyThread: TMyThread; 
begin 
  MyThread := TMyThread.Create(True); 
  MyThread.Resume; 
end; 
 
//可簡(jiǎn)化為: 
procedure TForm1.Button1Click(Sender: TObject); 
begin 
  with TMyThread.Create(True) do Resume; 
end;

一、入門
㈠、

function CreateThread( 
  lpThreadAttributes: Pointer;           {安全設(shè)置} 
  dwStackSize: DWORD;                    {堆棧大小} 
  lpStartAddress: TFNThreadStartRoutine; {入口函數(shù)} 
  lpParameter: Pointer;                  {函數(shù)參數(shù)} 
  dwCreationFlags: DWORD;                {啟動(dòng)選項(xiàng)} 
  var lpThreadId: DWORD                  {輸出線程 ID } 
): THandle; stdcall;                     {返回線程句柄}

在 Windows 上建立一個(gè)線程, 離不開 CreateThread 函數(shù);
TThread.Create 就是先調(diào)用了 BeginThread (Delphi 自定義的), BeginThread 又調(diào)用的 CreateThread.
既然有建立, 就該有釋放, CreateThread 對(duì)應(yīng)的釋放函數(shù)是: ExitThread, 譬如下面代碼:

procedure TForm1.Button1Click(Sender: TObject); 
begin 
  ExitThread(0); {此句即可退出當(dāng)前程序, 但不建議這樣使用} 
end;

代碼注釋:
當(dāng)前程序是一個(gè)進(jìn)程, 進(jìn)程只是一個(gè)工作環(huán)境, 線程是工作者;
每個(gè)進(jìn)程都會(huì)有一個(gè)啟動(dòng)線程(或叫主線程), 也就是說: 我們之前大量的編碼都是寫給這個(gè)主線程的;
上面的 ExitThread(0); 就是退出這個(gè)主線程;
系統(tǒng)不允許一個(gè)沒有線程的進(jìn)程存在, 所以程序就退出了.
另外: ExitThread 函數(shù)的參數(shù)是一個(gè)退出碼, 這個(gè)退出碼是給之后的其他函數(shù)用的, 這里隨便給個(gè)無符號(hào)整數(shù)即可.

或許你會(huì)說: 這個(gè) ExitThread 挺好用的; 其實(shí)不管是用 API 還是用 TThread 類寫多線程, 我們很少用到它; 因?yàn)?
1、假如直接使用 API 的 CreateThread, 它執(zhí)行完入口函數(shù)后會(huì)自動(dòng)退出, 無需 ExitThread;
2、用 TThread 類建立的線程又絕不能使用 ExitThread 退出; 因?yàn)槭褂?TThread 建立線程時(shí)會(huì)同時(shí)分配更多資源(譬如你自定義的成員、還有它的祖先類(TObject)分配的資源等等), 如果用 ExitThread 給草草退出了, 這些資源將得不到釋放而導(dǎo)致內(nèi)存泄露. 盡管 Delphi 提供了 EndThread(其內(nèi)部調(diào)用 ExitThread), 這也不需要我們手動(dòng)操作(假如非要手動(dòng)操作也是件很麻煩的事情, 因?yàn)楹芏鄷r(shí)候你不知道線程是什么時(shí)候執(zhí)行完畢的).
除了 CreateThread, 還有一個(gè) CreateRemoteThread, 可在其他進(jìn)程中建立線程, 這不應(yīng)該是現(xiàn)在學(xué)習(xí)的重點(diǎn);
現(xiàn)在先集中精力把 CreateThread 的參數(shù)搞徹底.

倒著來吧, 先談?wù)?CreateThread 將要返回的 "線程句柄".

"句柄" 類似指針, 但通過指針可讀寫對(duì)象, 通過句柄只是使用對(duì)象;
有句柄的對(duì)象一般都是系統(tǒng)級(jí)別的對(duì)象(或叫內(nèi)核對(duì)象); 之所以給我們的是句柄而不是指針, 目的只有一個(gè): "安全";
貌似通過句柄能做很多事情, 但一般把句柄提交到某個(gè)函數(shù)(一般是系統(tǒng)函數(shù))后, 我們也就到此為止很難了解更多了; 事實(shí)上是系統(tǒng)并不相信我們.

不管是指針還是句柄, 都不過是內(nèi)存中的一小塊數(shù)據(jù)(一般用結(jié)構(gòu)描述), 微軟并沒有公開句柄的結(jié)構(gòu)細(xì)節(jié), 猜一下它應(yīng)該包括: 真實(shí)的指針地址、訪問權(quán)限設(shè)置、引用計(jì)數(shù)等等.

既然 CreateThread 可以返回一個(gè)句柄, 說明線程屬于 "內(nèi)核對(duì)象".
實(shí)際上不管線程屬于哪個(gè)進(jìn)程, 它們?cè)谙到y(tǒng)的懷抱中是平等的; 在優(yōu)先級(jí)(后面詳談)相同的情況下, 系統(tǒng)會(huì)在相同的時(shí)間間隔內(nèi)來運(yùn)行一下每個(gè)線程, 不過這個(gè)間隔很小很小, 以至于讓我們誤以為程序是在不間斷地運(yùn)行.

這時(shí)你應(yīng)該有一個(gè)疑問: 系統(tǒng)在去執(zhí)行其他線程的時(shí)候, 是怎么記住前一個(gè)線程的數(shù)據(jù)狀態(tài)的?
有這樣一個(gè)結(jié)構(gòu) TContext, 它基本上是一個(gè) CPU 寄存器的集合, 線程是數(shù)據(jù)就是通過這個(gè)結(jié)構(gòu)切換的, 我們也可以通過 GetThreadContext 函數(shù)讀取寄存器看看.

附上這個(gè)結(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 的最后一個(gè)參數(shù)是 "線程的 ID";
既然可以返回句柄, 為什么還要輸出這個(gè) ID? 現(xiàn)在我知道的是:
1、線程的 ID 是唯一的; 而句柄可能不只一個(gè), 譬如可以用 GetCurrentThread 獲取一個(gè)偽句柄、可以用 DuplicateHandle 復(fù)制一個(gè)句柄等等.
2、ID 比句柄更輕便.

在主線程中 GetCurrentThreadId、MainThreadID、MainInstance 獲取的都是主線程的 ID.
㈡、啟動(dòng)選項(xiàng)

function CreateThread( 
  lpThreadAttributes: Pointer; 
  dwStackSize: DWORD; 
  lpStartAddress: TFNThreadStartRoutine; 
  lpParameter: Pointer; 
  dwCreationFlags: DWORD; {啟動(dòng)選項(xiàng)} 
  var lpThreadId: DWORD 
): THandle; stdcall;

CreateThread 的倒數(shù)第二個(gè)參數(shù) dwCreationFlags(啟動(dòng)選項(xiàng)) 有兩個(gè)可選值:
0: 線程建立后立即執(zhí)行入口函數(shù);
CREATE_SUSPENDED: 線程建立后會(huì)掛起等待.

可用 ResumeThread 函數(shù)是恢復(fù)線程的運(yùn)行; 可用 SuspendThread 再次掛起線程.
這兩個(gè)函數(shù)的參數(shù)都是線程句柄, 返回值是執(zhí)行前的掛起計(jì)數(shù).

什么是掛起計(jì)數(shù)?
SuspendThread 會(huì)給這個(gè)數(shù) +1; ResumeThread 會(huì)給這個(gè)數(shù) -1; 但這個(gè)數(shù)最小是 0.
當(dāng)這個(gè)數(shù) = 0 時(shí), 線程會(huì)運(yùn)行; > 0 時(shí)會(huì)掛起.
如果被 SuspendThread 多次, 同樣需要 ResumeThread 多次才能恢復(fù)線程的運(yùn)行.

在下面的例子中, 有新線程不斷給一個(gè)全局變量賦隨機(jī)值;
同時(shí)窗體上的 Timer 控件每隔 1/10 秒就把這個(gè)變量寫在窗體標(biāo)題;
在這個(gè)過程中演示了 ResumeThread、SuspendThread 兩個(gè)函數(shù).

//上面圖片中演示的代碼。 
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;     {全局變量, 用于記錄隨機(jī)數(shù)} 
 
{線程入口函數(shù)} 
function MyThreadFun(p: Pointer): Integer; stdcall; 
begin 
  while True do {假如線程不掛起, 這個(gè)循環(huán)將一直循環(huán)下去} 
  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; 
 
{喚醒并繼續(xù)線程} 
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.

㈢、入口函數(shù)的參數(shù)

function CreateThread( 
  lpThreadAttributes: Pointer; 
  dwStackSize: DWORD; 
  lpStartAddress: TFNThreadStartRoutine; 
  lpParameter: Pointer;  {入口函數(shù)的參數(shù)} 
  dwCreationFlags: DWORD; 
  var lpThreadId: DWORD 
): THandle; stdcall;

線程入口函數(shù)的參數(shù)是個(gè)無類型指針(Pointer), 用它可以指定任何數(shù)據(jù); 本例是把鼠標(biāo)點(diǎn)擊窗體的坐標(biāo)傳遞給線程的入口函數(shù), 每次點(diǎn)擊窗體都會(huì)創(chuàng)建一個(gè)線程.

運(yùn)行效果圖:

//上面演示的代碼 
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; {這個(gè)坐標(biāo)點(diǎn)將會(huì)已指針的方式傳遞給線程, 它應(yīng)該是全局的} 
 
function MyThreadFun(p: Pointer): Integer; stdcall; 
var 
  i: Integer; 
  pt2: TPoint;       {因?yàn)橹羔槄?shù)給的點(diǎn)隨時(shí)都在變, 需用線程的局部變量存起來} 
begin 
  pt2 := PPoint(p)^; {轉(zhuǎn)換} 
  for i := 0 to 1000000 do 
  begin 
    with Form1.Canvas do begin 
      Lock; 
      TextOut(pt2.X, pt2.Y, IntToStr(i)); 
      Unlock; 
    end; 
  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); 
  {下面這種寫法更好理解, 其實(shí)不必, 因?yàn)?nbsp;PPoint 會(huì)自動(dòng)轉(zhuǎn)換為 Pointer 的} 
  //CreateThread(nil, 0, @MyThreadFun, Pointer(@pt), 0, ID); 
end; 
 
end.

這個(gè)例子還有不嚴(yán)謹(jǐn)?shù)牡胤? 當(dāng)一個(gè)線程 Lock 窗體的 Canvas 時(shí), 其他線程在等待; 線程在等待時(shí), 其中的計(jì)數(shù)也還在增加. 這也就是說: 現(xiàn)在并沒有去處理線程的同步; 同步是多線程中最重要的課題, 快到了.

另外有個(gè)小技巧: 線程函數(shù)的參數(shù)是個(gè) 32 位(4個(gè)字節(jié))的指針, 僅就本例來講, 可以讓它的 "高16位" 和 "低16位" 分別攜帶 X 和 Y; 這樣就不需要哪個(gè)全局的 pt 變量了.
其實(shí)在 Windows 的消息中就是這樣傳遞坐標(biāo)的, 在 Windows 的消息中一般高字節(jié)是 Y、低字節(jié)是 X; 咱們這么來吧, 這樣還可以使用給消息準(zhǔn)備的一些方便的函數(shù).

重寫本例代碼(當(dāng)然運(yùn)行效果和窗體文件都是一樣的):

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 函數(shù)可以像下面這樣: } 
  //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; 
  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 等函數(shù), 可以像下面這樣: } 
  //num := Y shl 16 + X; 
  CreateThread(nil, 0, @MyThreadFun, Ptr(num), 0, ID); 
  {上面的 Ptr 是專門將一個(gè)數(shù)字轉(zhuǎn)換為指針的函數(shù), 當(dāng)然也可以這樣: } 
  //CreateThread(nil, 0, @MyThreadFun, Pointer(num), 0, ID); 
end; 
 
end.

㈣、入口函數(shù)的指針

function CreateThread( 
  lpThreadAttributes: Pointer; 
  dwStackSize: DWORD; 
  lpStartAddress: TFNThreadStartRoutine; {入口函數(shù)的指針} 
  lpParameter: Pointer;  
  dwCreationFlags: DWORD; 
  var lpThreadId: DWORD 
): THandle; stdcall;

到了入口函數(shù)了, 學(xué)到這個(gè)地方, 我查了一個(gè)入口函數(shù)的標(biāo)準(zhǔn)定義, 這個(gè)函數(shù)的標(biāo)準(zhǔn)返回值應(yīng)該是 DWORD, 不過這函數(shù)在 Delphi 的 System 單元定義的是: TThreadFunc = function(Parameter: Pointer): Integer; 我以后會(huì)盡量使用 DWORD 做入口函數(shù)的返回值.

這個(gè)返回值有什么用呢?
等線程退出后, 我們用 GetExitCodeThread 函數(shù)獲取的退出碼就是這個(gè)返回值!

如果線程沒有退出, GetExitCodeThread 獲取的退出碼將是一個(gè)常量 STILL_ACTIVE (259); 這樣我們就可以通過退出碼來判斷線程是否已退出.

還有一個(gè)問題: 前面也提到過, 線程函數(shù)不能是某個(gè)類的方法! 假如我們非要線程去執(zhí)行類中的一個(gè)方法能否實(shí)現(xiàn)呢?
盡管可以用 Addr(類名.方法名) 或 MethodAddress('published 區(qū)的方法名') 獲取類中方法的地址, 但都不能當(dāng)做線程的入口函數(shù), 原因可能是因?yàn)轭愔械姆椒ǖ牡刂肥窃趯?shí)例化為對(duì)象時(shí)動(dòng)態(tài)分配的.
后來換了個(gè)思路, 其實(shí)很簡(jiǎn)單: 在線程函數(shù)中再調(diào)用方法不就得了, 估計(jì) TThread 也應(yīng)該是這樣.

下面的例子就嘗試了用線程調(diào)用 TForm1 類中的方法, 并測(cè)試了退出碼的相關(guān)問題.

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; {準(zhǔn)備給線程使用的方法} 
  end; 
 
var 
  Form1: TForm1; 
 
implementation 
 
{$R *.dfm} 
 
var 
  hThread: THandle; 
 
{線程入口函數(shù)} 
function MyThreadFun(p: Pointer): DWORD; stdcall; 
begin 
  Form1.FormProc; {調(diào)用 TForm1 類的方法} 
  Result := 99;   {這個(gè)返回值將成為線程的退出代碼, 99 是我隨意給的數(shù)字} 
end; 
 
{TForm1 的方法, 本例中是給線程的入口函數(shù)調(diào)用的} 
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; 
  end; 
end; 
 
{建立并執(zhí)行線程} 
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 := '線程還未啟動(dòng)'; 
    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 的第二個(gè)參數(shù)是分配給線程的堆棧大小.
這首先這可以讓我們知道: 每個(gè)線程都有自己獨(dú)立的堆棧(也擁有自己的消息隊(duì)列).

什么是堆棧? 其實(shí)堆是堆、棧是棧, 有時(shí) "棧" 也被叫做 "堆棧".
它們都是進(jìn)程中的內(nèi)存區(qū)域, 主要是存取方式不同(棧:先進(jìn)后出; 堆:先進(jìn)先出);
"棧"(或叫堆棧)適合存取臨時(shí)而輕便的變量, 主要用來儲(chǔ)存局部變量; 譬如 for i := 0 to 99 do 中的 i 就只能存于棧中, 你把一個(gè)全局的變量用于 for 循環(huán)計(jì)數(shù)是不可以的.

現(xiàn)在我們知道了線程有自己的 "棧", 并且在建立線程時(shí)可以分配棧的大小.

前面所有的例子中, 這個(gè)值都是 0, 這表示使用系統(tǒng)默認(rèn)的大小, 默認(rèn)和主線程棧的大小一樣, 如果不夠用會(huì)自動(dòng)增長;
那主線程的棧有多大? 這個(gè)值是可以設(shè)定的: Project -> Options -> linker -> memory size(如圖)

棧是私有的但堆是公用的, 如果不同的線程都來使用一個(gè)全局變量有點(diǎn)亂套;
為解決這個(gè)問題 Delphi 為我們提供了一個(gè)類似 var 的 ThreadVar 關(guān)鍵字, 線程在使用 ThreadVar 聲明的全局變量時(shí)會(huì)在各自的棧中留一個(gè)副本, 這樣就解決了沖突. 不過還是盡量使用局部變量, 或者在繼承 TThread 時(shí)使用類的成員變量, 因?yàn)?ThreadVar 的效率不好, 據(jù)說比局部變量能慢 10 倍.

在下面的例子就測(cè)試了用 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 秒鐘再繼續(xù)} 
  end; 
end; 
 
procedure TForm1.Button1Click(Sender: TObject); 
var 
  ID: DWORD; 
begin 
  {借入口函數(shù)的參數(shù)傳遞了一個(gè)坐標(biāo)點(diǎn)中的 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è)置

function CreateThread( 
  lpThreadAttributes: Pointer; {安全設(shè)置} 
  dwStackSize: DWORD; 
  lpStartAddress: TFNThreadStartRoutine;  
  lpParameter: Pointer;  
  dwCreationFlags: DWORD; 
  var lpThreadId: DWORD 
): THandle; stdcall;

CreateThread 的第一個(gè)參數(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; 這是另一個(gè)結(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ù)雜的, 但我們?cè)诙嗑€程編程時(shí)不需要去設(shè)置它們, 大都是使用默認(rèn)設(shè)置(也就是賦值為 nil).

我覺得有必要在此刻了解的是: 建立系統(tǒng)內(nèi)核對(duì)象時(shí)一般都有這個(gè)屬性(TSecurityAttributes);
在接下來多線程的課題中要使用一些內(nèi)核對(duì)象, 不如先盤點(diǎn)一下, 到時(shí)碰到這個(gè)屬性時(shí)給個(gè) nil 即可, 不必再費(fèi)神.

{建立事件} 
function CreateEvent( 
  lpEventAttributes: PSecurityAttributes; {!} 
  bManualReset: BOOL; 
  bInitialState: BOOL; 
  lpName: PWideChar 
): THandle; stdcall; 
 
{建立互斥} 
function CreateMutex( 
  lpMutexAttributes: PSecurityAttributes; {!} 
  bInitialOwner: BOOL; 
  lpName: PWideChar 
): THandle; stdcall; 
 
{建立信號(hào)} 
function CreateSemaphore( 
  lpSemaphoreAttributes: PSecurityAttributes; {!} 
  lInitialCount: Longint; 
  lMaximumCount: Longint; 
  lpName: PWideChar 
): THandle; stdcall; 
 
{建立等待計(jì)時(shí)器} 
function CreateWaitableTimer( 
  lpTimerAttributes: PSecurityAttributes; {!} 
  bManualReset: BOOL; 
  lpTimerName: PWideChar 
): THandle; stdcall;

上面的四個(gè)系統(tǒng)內(nèi)核對(duì)象(事件、互斥、信號(hào)、計(jì)時(shí)器)都是線程同步的手段, 從這也能看出處理線程同步的復(fù)雜性; 不過這還不是全部, Windows Vista 開始又增加了 Condition variables(條件變量)、Slim Reader-Writer Locks(讀寫鎖)等同步手段.

不過最簡(jiǎn)單、最輕便(速度最快)的同步手段還是 CriticalSection(臨界區(qū)), 但它不屬于系統(tǒng)內(nèi)核對(duì)象, 當(dāng)然也就沒有句柄、沒有 TSecurityAttributes 這個(gè)安全屬性, 這也導(dǎo)致它不能跨進(jìn)程使用; 不過寫多線程時(shí)一般不用跨進(jìn)程, 所以 CriticalSection 應(yīng)該是最常用的同步手段.

二、臨界區(qū)。
先看一段程序, 代碼文件:

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); 
  CreateThread(nil, 0, @MyThreadFun, nil, 0, ID); 
  CreateThread(nil, 0, @MyThreadFun, nil, 0, ID); 
end; 
 
procedure TForm1.FormCreate(Sender: TObject); 
begin 
  ListBox1.Align := alLeft; 
end; 
 
end.

在這段程序中, 有三個(gè)線程幾乎是同時(shí)建立, 向窗體中的 ListBox1 中寫數(shù)據(jù), 最后寫出的結(jié)果是這樣的:

能不能讓它們別打架, 一個(gè)完了另一個(gè)再來? 這就要用到多線程的同步技術(shù).
前面說過, 最簡(jiǎn)單的同步手段就是 "臨界區(qū)".

先說這個(gè) "同步"(Synchronize), 首先這個(gè)名字起的不好, 我們好像需要的是 "異步"; 其實(shí)異步也不準(zhǔn)確...
管它叫什么名字呢, 它的目的就是保證不沖突、有次序、都發(fā)生.

"臨界區(qū)"(CriticalSection): 當(dāng)把一段代碼放入一個(gè)臨界區(qū), 線程執(zhí)行到臨界區(qū)時(shí)就獨(dú)占了, 讓其他也要執(zhí)行此代碼的線程先等等; 這和前面用的 Lock 和 UnLock 差不多; 使用格式如下:

var CS: TRTLCriticalSection;   {聲明一個(gè) TRTLCriticalSection 結(jié)構(gòu)類型變量; 它應(yīng)該是全局的} 
InitializeCriticalSection(CS); {初始化} 
EnterCriticalSection(CS);      {開始: 輪到我了其他線程走開} 
LeaveCriticalSection(CS);      {結(jié)束: 其他線程可以來了} 
DeleteCriticalSection(CS);     {刪除: 注意不能過早刪除} 
 
//也可用 TryEnterCriticalSection 替代 EnterCriticalSection.

用上臨界區(qū), 重寫上面的代碼, 運(yùn)行效果圖:

//用臨界區(qū)重寫后的代碼文件: 
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); 
  CreateThread(nil, 0, @MyThreadFun, nil, 0, ID); 
  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 單元給封裝了一個(gè) 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); 
  CreateThread(nil, 0, @MyThreadFun, nil, 0, ID); 
  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.

三、等待函數(shù) WaitForSingleObject
一下子跳到等待函數(shù) WaitForSingleObject, 是因?yàn)橄旅娴?Mutex、Semaphore、Event、WaitableTimer 等同步手段都要使用這個(gè)函數(shù); 不過等待函數(shù)可不止 WaitForSingleObject 它一個(gè), 但它最簡(jiǎn)單.

function WaitForSingleObject( 
  hHandle: THandle;      {要等待的對(duì)象句柄} 
  dwMilliseconds: DWORD  {等待的時(shí)間, 單位是毫秒} 
): DWORD; stdcall;       {返回值如下:} 
 
WAIT_OBJECT_0  {等著了, 本例中是: 等的那個(gè)進(jìn)程終于結(jié)束了} 
WAIT_TIMEOUT   {等過了點(diǎn)(你指定的時(shí)間), 也沒等著} 
WAIT_ABANDONED {好不容易等著了, 但人家還是不讓咱執(zhí)行; 這一般是互斥對(duì)象} 
 
//WaitForSingleObject 的第二個(gè)參數(shù)一般給常數(shù)值 INFINITE, 表示一直等下去, 死等.

WaitForSingleObject 等待什么? 在多線程里就是等待另一個(gè)線程的結(jié)束, 快來執(zhí)行自己的代碼; 不過它可以等待的對(duì)象可不止線程; 這里先來一個(gè)等待另一個(gè)進(jìn)程結(jié)束的例子, 運(yùn)行效果圖:

//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; {進(jìn)程句柄} 
 
{等待一個(gè)指定句柄的進(jìn)程什么時(shí)候結(jié)束} 
function MyThreadFun(p: Pointer): DWORD; stdcall; 
begin 
  if WaitForSingleObject(hProcess, INFINITE) = WAIT_OBJECT_0 then 
    Form1.Text := Format('進(jìn)程 %d 已關(guān)閉', [hProcess]); 
  Result := 0; 
end; 
 
{啟動(dòng)一個(gè)進(jìn)程, 并建立新線程等待它的結(jié)束} 
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 打開記事本并獲取其進(jìn)程句柄, 然后建立線程監(jiān)視} 
  FillChar(sInfo, SizeOf(sInfo), 0); 
  if CreateProcess(Path, nil, nil, nil, False, 0, nil, nil, sInfo, pInfo) then 
  begin 
    hProcess := pInfo.hProcess;                           {獲取進(jìn)程句柄} 
    Text := Format('進(jìn)程 %d 已啟動(dòng)', [hProcess]);  
    CreateThread(nil, 0, @MyThreadFun, nil, 0, ThreadID); {建立線程監(jiān)視} 
  end; 
end; 
 
end.