RSS订阅 | 匿名投稿
您的位置:网站首页 > 线程 > 正文

Delphi的线程类

作者:admin 来源: 日期:2011/8/22 16:45:13 人气: 标签:

 

转自http://blog.csdn.net/fenger8293

本文是没有写过delphi的多线程,对delphi的线程类TThread不熟悉的人而写的,主要从 TThread的源代码入手.

 Delphi为多线程的实现专门封装了一个TThread类来实现,我们从Create函数入手来认识一下这个类,这里一般都是windows下的开发,所以先去掉linux环境的代码:

constructor TThread.Create(CreateSuspended: Boolean);
begin
  inherited Create;
  AddThread;
  FSuspended := CreateSuspended;
  FCreateSuspended := CreateSuspended;
  FHandle := BeginThread(nil, 0, @ThreadProc, Pointer(Self), CREATE_SUSPENDED, FThreadID);
  if FHandle = 0 then
    raise EThread.CreateResFmt(@SThreadCreateError, [SysErrorMessage(GetLastError)]);
end;

TThread的构造函数只有一个CreateSuspended参数,该参数标示线程创建后是否挂起.

AddThread过程主要是创建一个同步时要用到的list及对线程数做一个计数.

这里主要是一个BeginThread函数的调用,BeginThread是对windows API函数CreateThread的一个封装,大家可以点进去看以下,基本没做什么操作,CreateThread的一个重要参数就是线程函数的入口地址(这里的
@ThreadProc),该函数的内容就是线程要做的真正的事(对于后面的Pointer(Self),和CREATE_SUSPENDED参数第一个是用于向线程传入参数时所要用到的指针,这里指向了self线程本身,因为在线程函数ThreadProc里并没有看到使用到它这里就不先多说了,在以后我的完成端口的例子里我会介绍如何使用它,CREATE_SUSPENDED是告诉线程创建后先挂起).我们可以点进去看下ThreadProc函数的定义

function ThreadProc(Thread: TThread): Integer;
var
  FreeThread: Boolean;
begin
  try
    if not Thread.Terminated then
    try
      Thread.Execute;
    except
      Thread.FFatalException := AcquireExceptionObject;
    end;
  finally
    FreeThread := Thread.FFreeOnTerminate;
    Result := Thread.FReturnValue;
    Thread.FFinished := True;
    Thread.DoTerminate;
    if FreeThread then Thread.Free;
    EndThread(Result);
  end;
end;

这里我们可以看到线程函数是先判断Terminated ,否的话执行Execute,最后根据FreeOnTerminate的属性决定是否释放线程.我们看Execute的定义,它是一个纯虚方法,所以用户在用继承TThread类来实现多线程时必须要覆盖Execute方法,添加代码告诉线程要做什么事.

有的人要问了,既然上面的BeginThread创建线程时是挂起的,那线程是什么时候开始工作的呢,这里就有看具体,create函数传入的参数了,如果是false表示线程创建后立即执行,具体是在

procedure TThread.AfterConstruction;
begin
  if not FCreateSuspended then
    Resume;
end;

方法里,这个方法是覆盖了TObject的虚方法,它在类创建后被delphi自动调用,我们看到它就2句代码,即如果传入的为false时即调用Resume方法,当Create指定线程创建后挂起时,用户必须自己调用此方法让线程开始执行.

TThread类提供了一个同步函数Synchronize,用于在多线程时做好同步操作,它的代码如下:

procedure TThread.Synchronize(Method: TThreadMethod);
var
  SyncProc: TSyncProc;
begin
  if GetCurrentThreadID = MainThreadID then
    Method
  else
  begin
    SyncProc.Signal := CreateEvent(nil, True, False, nil);
    try
      EnterCriticalSection(ThreadLock);
      try
        FSynchronizeException := nil;
        FMethod := Method;
        SyncProc.Thread := Self;
        SyncList.Add(@SyncProc);
        ProcPosted := True;
        if Assigned(WakeMainThread) then
          WakeMainThread(Self);
        LeaveCriticalSection(ThreadLock);
        try
          WaitForSingleObject(SyncProc.Signal, INFINITE);
        finally
          EnterCriticalSection(ThreadLock);
        end;
      finally
        LeaveCriticalSection(ThreadLock);
      end;
    finally
      CloseHandle(SyncProc.Signal);
    end;
    if Assigned(FSynchronizeException) then raise FSynchronizeException;
  end;
end;

它只有一个参数Method,我们可以看到它的定义 TThreadMethod = procedure of object;说明它是一个过程类型,需要传入一个过程的过程名.这个函数的代码看上去不难,但你如果稍微仔细点又会发现好象有点不对劲,因为除了当当前线程是主线程时会直接调用Method过程,下面并没有调用Method过程,那么它是在哪调用同步过程的呢?其实delphi的线程处理里是把同步过程的代码放到了主线程里调用,即Application所在的线程。我们从上面看到当当前线程不是主线程时,它首先创建了一个事件(SyncProc结构定义了一个事件和一个TThread对象),并将当前线程对象绑定到SyncProc结构,同时把这个结构的地址加到AddThread(Create方法里调用的第一个过程)里创建的SyncList里,后面它执行了一句这样的代码

if Assigned(WakeMainThread) then
          WakeMainThread(Self);

从定义可以看到WakeMainThread是一个事件变量,而且默认指向nil,我们在classes单元里可以搜到只有刚出现的几个地方有出现WakeMainThread,也就是说它没有在这个单元里的任何地方被赋值或调用,那么它是在哪被赋值的呢?(如果没有被赋值,那它永远会是nil,这些代码在这里就完全没有意义了,borland的那些工程师不至于犯这么低级的错误),其实通过全文搜索,你可以发现它在Forms单元里被赋值了

procedure TApplication.WakeMainThread(Sender: TObject);
begin
  PostMessage(Handle, WM_NULL, 0, 0);
end;

procedure TApplication.HookSynchronizeWakeup;
begin
  Classes.WakeMainThread := WakeMainThread;
end;
原来饶了一圈它只是要给Application发一个WM_NULL消息,而HookSynchronizeWakeup也是在Application创建时被调用了。我们再来看看Application处理WM_NULL的代码,在哪找?当然是WndProc里先找了,发现就在这里调用了,而且是调用了classes单元的CheckSynchronize方法。原来饶了一圈又回来了。

function CheckSynchronize: Boolean;
var
  SyncProc: PSyncProc;
begin
  if GetCurrentThreadID <> MainThreadID then
    raise EThread.CreateResFmt(@SCheckSynchronizeError, [GetCurrentThreadID]);
  if ProcPosted then
  begin
    EnterCriticalSection(ThreadLock);
    try
      Result := (SyncList <> nil) and (SyncList.Count > 0);
      if Result then
      begin
        while SyncList.Count > 0 do
        begin
          SyncProc := SyncList[0];
          SyncList.Delete(0);
          try
            SyncProc.Thread.FMethod;
          except
            SyncProc.Thread.FSynchronizeException := AcquireExceptionObject;
          end;
          SetEvent(SyncProc.signal);
        end;
        ProcPosted := False;
      end;
    finally
      LeaveCriticalSection(ThreadLock);
    end;
  end else Result := False;
end;

第一句不用说了,既然放在主线程里执行,那不是主线程就报错。接着判断的ProcPosted已经在前面设置为true了,接下来就是对SyncList里的所有add进来要同步执行的函数循环执行并删除,执行完一个给它一个信号(SyncProc.signal)。到此我们对TThread类对线程的封装应该有所了解了吧

 

 

//-------------------------------------------转载---------------------------------------------------------

Delphi多线程处理(转载)

2007-09-03 01:23

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

      使用临界区是比较方便而且概念比较清晰的的线程同步机制,应用比较广泛。

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


读完这篇文章后,您心情如何?
0
0
0
0
0
0
0
0
本文网址: