delphi 中幾種多線程操做方式

時間 2019-11-13

原文原文鏈接

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

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

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

主線程又程爲UI線程。安全

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

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

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

先試試這個:dom

procedure TForm1.Button1Click(Sender: TObject); var 
  i: Integer; begin 
  for i := 0 to 500000 do 
  begin 
    Canvas.TextOut(10, 10, IntToStr(i)); 
  end; 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; end;

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

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

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

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; 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、入門
㈠、

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

在這段程序中, 有三個線程幾乎是同時創建, 向窗體中的 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); 
  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 單元給封裝了一個 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.

3、等待函數 WaitForSingleObject
一會兒跳到等待函數 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; 
 end.