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-4 多线程的同步机制

     同步机制，实际上是事件驱动机制，意思是让线程平时处于“休眠”状态，除非发生某个事件才触发。
     例如一个拷贝文件，拷贝线程完成一个程序块后，再唤醒进程条线程做一个格的填充。
     研究多线程的同步机制的必要性在于，多线程同步工作时，如果同时调用相同的资源，就可能会出现问题，一般读出是不会有问题的，但是，如果写入（全局变量、数据库），就会发生冲突，甚至产生死
锁和竞争问题。

一、使用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）临界区

    使用线程的时候，遇到的一个基本的问题，就是多个线程访问同一个对象，比如访问相同的文件、DLL、相同的通讯资源，特别是数据库的访问，当多个线程对同一数据库字段写入的时候，其结果会出
现不确定性。
     临界区用于解决这个问题，它可以保证线程使用敏感数据的时候，阻赛其他的线程访问名干数据，使用时首先要初始化，其声明一个TRTLCriticalSection类型的变量：

var
   CS:TRTLCriticalSection;

初始化：

     initializeCriticalSection(cs);

独占

EnterCriticalSection(cs);

解除独占

LeaveCriticalSection(CS);

     使用临界区是比较方便而且概念比较清晰的的线程同步机制，应用比较广泛。
     请注意，临界区只能在一个进程内使用，首先要标记出把数据作为临界区操作的那些代码，在这部分代码执行前，计算机首先要查看一下全局记录，已确定是否有其它线程在临界区中，同时也要查看这个临界区是否和第一个临界区相关，也就是说同一个程序中可能会有几个不同的临界区，然后计算机再决定运行策略

TThread在Classes单元中声明,直接从TObject继承下来的,因为,它不是组件.TThread是个抽象类,所以不能创建TThread的实例,而只能创建其派生类的实例.

利用TThread类来编写多线程应用程序的一般步骤如下:

[步骤一] 从TThread类派生出一个新的线程类.
[步骤二] 创建线程对象
[步骤三] 设置线程对象的属性,比如优先级等.
[步骤四] 根据具体情况挂起或唤醒线程.
[步骤五] 结束线程.

从TThread类派生出一个新的线程类的过程非常简单:通常菜单"File|New|Other..."打开"New Items"对话框,选中"New"页的"Thread Object"项,单击"OK"按钮,接着在弹出的"New Thread Object"对话框中输入新的线程类的名称.通常线程类的名称以T开头,以Thread结束,例如"TTestThread".

TThread类还有以下的一些属性、方法和事件:

Priority属性:整型,设置线程的优先级.
Return Value属性:返回值,即当线程结束时返回给其他线程的一个数值.
Suspended属性:判断线程是否被挂起.
ThreadID属性:线程标识号,是整个系统中线程的标识号.
DoTerminate过程:产生一个OnTerminate事件,但是不结束线程的执行.
Resume过程:唤醒一个线程继续执行.
Suspend过程:挂起一个线程.
Synchronize过程:由主VCL线程调用的一个同步过程.
Terminate过程:将Terminated属性设置为True,终止线程的执行.
WairFor方法:等待线程的终止并返回Return Value属性的数值.
线程优先级的设定：
TThreadPriority = (tpIdle, tpLowest, tpLower, tpNormal, tpHigher, tpHighest, tpTimeCritical);
下面进行一个简单的示例：
线程单元：
unit untPaintThread;
interface
uses
Classes;
type
PaintThread = class(TThread)
private
    { Private declarations }
protected
    procedure Execute; override;
end;
implementation
uses untMain,Graphics;
procedure PaintThread.Execute;
var
x,y: Integer;
begin
{ Place thread code here }
Randomize;
repeat
    x := Random(Form1.ClientWidth);
    y := Random(Form1.ClientHeight);
    with Form1.Canvas do
    begin
      Lock;   //使用vcl中的资源的时候进行相应的加锁
      try
        Pixels[x,y] := clBlue;
      finally
      Unlock; // 使用完后进行相应的释放
      end;  
    end;
until Terminated;
end;
end.
主线程单元：
unit untMain;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs,untPaintThread, StdCtrls;
type
TForm1 = class(TForm)
    btn1: TButton;
    btn2: TButton;
    procedure btn1Click(Sender: TObject);
    procedure btn2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
private
    { Private declarations }
    pthread: PaintThread;
public
    { Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.btn1Click(Sender: TObject);
begin
    pthread.Resume;
end;
procedure TForm1.btn2Click(Sender: TObject);
begin
   pthread.Suspend;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
pthread := PaintThread.Create(true);
end;
procedure TForm1.FormDestroy(Sender: TObject);
begin
    pthread.Free;
end;
end.

多线程程序访问VCL的时候要特别注意,只能逐个地实现对VCL的访问.具体可以采用下面的两个方法:
(1) 锁定VCL对象
对于一些具有锁定功能的对象,可以在锁定之后再进去具体操作,比如上面的方法!!!.
(2) 使用Synchronize函数
TThread类的Synchronize过程声明如下:

type TThreadMethod=procedure of object;
procedure Synchronize(Method:TThreadMethod);

其他参数Method为一个不带参数的过程名.在这个不带参数的过程中是一些访问VCL的代码.
对Synchronize的调用是在Execute过程中,用来避免对VCL的并发访问.程序运行期间的具体过程实际上是由Synchronize过程来通知主线程,然后主线程在适当的时机执行Synchronize过程的参数列表中不带参数的过程.在多个线程的情况下,主线程将Synchronize过程所发的通知放到消息队列中,然后逐个地响应这些消息.通过这种机制Synchronize实现了线程之间的同步.
unit untmain;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Spin, ImgList;
type
TAnimThread = class(TThread)
private
    bt: TBitmap;
    procedure DrawGraphics;
protected
    procedure execute; override;
end;
type
TForm1 = class(TForm)
    il1: TImageList;
    SpinEdit1: TSpinEdit;
    lbl1: TLabel;
    lbl2: TLabel;
    btn1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure btn1Click(Sender: TObject);
private
    { Private declarations }
public
    { Public declarations }
    anmthread: TAnimThread;
end;
var
Form1: TForm1;
run:   Boolean;
implementation
{$R *.dfm}
{ TAnimThread }
procedure TAnimThread.DrawGraphics;
begin
   //这个地方使用了双缓冲技术
   Form1.Canvas.CopyRect(Bounds(0,0,Form1.Width,32),bt.Canvas,Bounds(0,0,Form1.Width,32));
   BitBlt(Form1.Canvas.Handle,0,0,Form1.Width,32,bt.Canvas.Handle,0,0,SRCCOPY);
end;
procedure TAnimThread.execute;
var
x,i: Integer;
dir: Boolean;
begin
bt := TBitmap.Create;
try
bt.Width := Form1.ClientWidth;
bt.Height := 32;
bt.Canvas.Pen.Color := clPurple;
bt.Canvas.Brush.Color := clSkyBlue;
bt.Canvas.Rectangle(0,0,Form1.Width,32);
dir := false;
x := 0;
i := 0;
repeat
begin
     Inc(i);
     bt.Canvas.Rectangle(0,0,Form1.Width,32);
     Form1.il1.Draw(bt.Canvas,x,0,i);
     Synchronize(DrawGraphics);
     Sleep(1* 100);
     if (i < 0) or(i>300) then
     dir := not dir;
     if dir then Inc(x) else Dec(x);
     if i > Form1.il1.Count - 1 then
        i := 0;
end;
until terminated;
finally
    bt.Free;
end;  
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
run := false;
end;
procedure TForm1.FormDestroy(Sender: TObject);
begin
    if not anmthread.Terminated then
    anmthread.Free;
end;
procedure TForm1.btn1Click(Sender: TObject);
begin
    run := not run;
    if run then begin
       anmthread := TAnimThread.Create(false);
    end else
        anmthread.Free;
    if btn1.Caption = '开始' then
        btn1.Caption := '结束'
    else btn1.Caption := '开始';
end;
end.