Delphi多线程处理

1-1多线程的基本概念

      WIN 98/NT/2000/XP 是个多任务操作系统，也就是：一个进程可以划分为多个线程，每个线程轮流占用CPU 运行时间和资源，或者说，把CPU 时间划成片，每个片分给不同的线程，这样，每个线程轮流的“挂起”和“唤醒”，由于时间片很小，给人的感觉是同时运行的。

      多线程带来如下好处：（自己阅读）

      1）避免瓶颈；

      2）并行操作；

      3）提高效率；

      在多线程中，通过优先级管理，可以使重要的程序优先操作，提高了任务管理的灵活性。

      另一方面，在多CPU 系统中，可以把不同的线程在不同的CPU 中执行，真正做到同时处理多任务（Win 98 只是模拟的，而Win/NT/2000是真正的多CPU同时操作）。

      多线程的两个概念：

      1）进程：也称任务，程序载入内存，并分配资源，称为“一个进程”。

     注意：进程本身并不一定要正在执行。进程由以下几部分组成：

      a>一个私有的地址空间，它是进程可以使用的一组虚拟内存地址空间；

      b>程序的相关代码、数据源；

      c>系统资源，比如操作系统同步对象等；

      d>至少包含一个线程（主线程）；

      2）线程：是程序的执行单位（线程本身并不包括程序代码，真正拥有代码的是进程），每个进程至少包括一个线程，称为主线程，一个进程如果有多个线程，就可以共享同一进程的资源，并可以并发执行。

      线程是进程的一个执行单元，是操作系统分配CPU 时间的基本实体，线程主要由如下两部分组成：

      a>数据结构；

      b>CPU 寄存器和堆栈；

      一个进程中的线程，可以独立运行，也可以控制另一个线程的运行。

      请注意：

      多线程不能滥用，书上提到了多线程的几个缺点（自阅）。

1-2 Tthread 对象

      虽然Windows 提供了比较多的多线程设计的API 函数，但是直接使用API 函数一方面极其不方便，而且使用不当还容易出错。为解决这个问题，Borland 公司率先推出了一种Tthread 对象，来解决多线程设计上的困难，简化了多线程问题的处理。

      应该注意，Tthread 对象是没有实例的，它和界面的交流，主要依靠主窗体（主VCL线程），这和其他对象使用上有些区别。

一、Tthread 对象的主要方法

      构造线程：

      constructor Create(CreateSuspended:boolean)

      其中：CreateSuspended=true    构造但不唤醒

                                               false 构造的同时即唤醒

      也可以用如下方法

      inheried Create(CreateSuspended:boolean)

      挂起线程：

      suspend

      （把线程挂起的次数加一）

      唤醒线程：

      resume

      （注意：注意这个属性是把线程挂起的次数减一，当次数为0 时，即唤醒。也就是说，线程挂起多少次，唤醒也需要多少次。同时挂起的时候将保持线程的地址指针不变，所以线程挂起后再唤醒，将从挂起的地方开始运行）

      析构（清除线程所占用的内存）：

      destroy

      终止线程（后面会具体讨论）:

      Terminate

二、线程应用的简单例子：

      下面通过一个例子说明上述方法的应用。我们知道，循环是独占性最强的运行方式之一，现在希望建立两个线程对象，实现循环的并行运行。具体方法如下：

      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相应的单元，这个例程为了简单，把大部分常用的单元都拷过去了，这并不是推荐的办法，因为这样一来会使程序的垃圾过

多，所以，一般要用什么拷什么。

三、常用的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。

四、线程的终止和退出：

      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;       //释放

      书上有相应的例子。

      五、线程的优先级：

      在多线程的情况下，一般要根据线程执行任务的重要性，给线程适当的优先级，一般如果量的线程同时申请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.多线程的同步机制

      同步机制，实际上是事件驱动机制，意思是让线程平时处于“休眠”状态，除非发生某个事件才触发。

      例如一个拷贝文件，拷贝线程完成一个程序块后，再唤醒进程条线程做一个格的填充。

      研究多线程的同步机制的必要性在于，多线程同步工作时，如果同时调用相同的资源，就可能会出现问题，一般读出是不会有问题的，但是，如果写入（全局变量、数据库），就会发生冲突，甚至产生死

锁和竞争问题。

一、使用Synchronize方法

      这个方法用于访问VCL 主线程所管理的资源，其方法的应用是：

      第一步：把访问主窗口（或主窗口控件资源）的代码放到线程的一个方法中；

      第二步：是在线程对象的Execute方法中，通过Synchronize方法使用该方法。

      实例：

      procedure Theater.Execute;

      begin

        Synchronize(update);    

      end;  

      procedure Theater.update;

      begin

        .........   

      end;    

      这里通过 Synchronize使线程方法update同步。

二、使用VCL类的Look方法

      在Delphi的IDE提供的构件中，有一些对象内部提供了线程的同步机制，工作线程可以直接使用这些控件，比如：Tfont，Tpen，TBitmap，TMetafile，Ticon等。另外，一个很重要的控件对象叫TCanvas，提供了一个Lock方法用于线程的同步，当一个线程使用此控件对象的时候，首先调用这个对象的Lock方法，然后对这个控件进行操作，完毕后再调用Unlock方法，释放对控间的控制权。

      例如：

      CanversObject.look;

           try

             画图

           finally

             CanversObject.unlock;

           end;

      {使用这个保护机制,保证不论有没有异常，unlock都会被执行否则很可能会发生死锁。在多线程设计的时候，应该很注意发生死锁的问题}

三、Waitfor方法

      当一个线程应该等待另一个线程结束时，可以调用Waitfor方法。这个方法属于等待线程对象，Waitfor方法的原型如下:

      Function Waitfor(Const Astring:string):string;

      比如在前面最基本的线程的例子中，唤醒线程的语句中加上

      thread1.resume;

      thread1.waitfor;

      thread2.resume;

      那么所有的线程都必须等待thread1运行完毕后才能运行，其中包括主线程，可以预想，由于thread1调用了主窗体的Edit控件，那么，在thread1运行中间，Edie1也不会显示。

      这就告诉我们，这样的代码是不能作为主线程的一部分的，如果与主窗体连接的线程内等待另一个线程结束，而另一个线程又要等待访问用户界面，就可能是程序陷于死锁。

      这点在应用的时候要谨慎。

四、利用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)

4、事件

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; 

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; 一般用在比较费时的循环中, 它会检查并先处理消息队列中的其他消息.

但这算不上多线程, 譬如: 运行中你拖动窗体, 循环会暂停下来...

在使用多线程以前, 让我们先简单修改一下程序:

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; 

细数上面程序的变化:

1、首先这还不是多线程的, 也会让窗体假 "死" 一会;

2、把执行代码写在了一个函数里, 但这个函数不属于 TForm1 的方法, 所以使用 Canvas 是必须冠以名称(Form1);

3、既然是个函数, (不管是否必要)都应该有返回值;

4、使用了 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; 

一、入门

㈠、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 类写多线程, 我们很少用到它; 因为:

1、假如直接使用 API 的 CreateThread, 它执行完入口函数后会自动退出, 无需 ExitThread;

2、用 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? 现在我知道的是:

1、线程的 ID 是唯一的; 而句柄可能不只一个, 譬如可以用 GetCurrentThread 获取一个伪句柄、可以用 DuplicateHandle 复制一个句柄等等.

2、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;