Delphi多线程编程基础入门

1. 概述

         对于开发人员来说,多线程是必备的知识,但相对来说,也是比较难的知识点。Delphi是一门古老而优秀的编程语言,它对多线程的处理有一些特殊的地方,本文尝试做一些简单的讲解,可以当作Delphi的多线程基础入门知识来阅读。如无特殊说明,所有例子都在XP操作系统中和Delphi7中调试通过。

2. 一个简单的例子

          在这一节中,我们将建立一个极为简单的例子,阐述Delphi中多线程的用法。

2.1 实现步骤

          第一步:在Delphi7 IDE中新建一个Application,如下图所示。


图1

          第二步:打开工程文件,输入{$APPTYPE CONSOLE},以便打开控制台,新建的线程在控制台输出一些文本。操作过程如下所示。


图2

图3

          第三步:新建一个单元文件Unit2,如下图所示。
图4

图5

          第四步:在新建的Unit2单元中输入如下代码:


图6

          在Unit1单元中输入如下代码:
图7

          第五步:点击“Save All”,保存相关文件,如下图所示:
图8

图9

          第六步:按F9运行程序,如下图所示:
图10

          在上图中,可以见到新的线程在运行了,输出了“I am a new thread”。

2.2 线程基础知识

2.2.1 新的线程与主线程的关系

          主线程也叫界面线程,就是窗体应用程序启动时,对应进程创建的第一条线程,该线程负责:
          1. 创建窗体、创建窗体上的控件。
          2. 响应键盘消息、鼠标消息等Windows消息。
          3. 负责创建新线程和其他事情。

          主线程以外的新线程也叫作工作线程,负责处理具体的事务。主线程创建新线程后,可以让新线程立即运行,也可以让它稍后运行。
          在下面的代码中:

myThread := TMyThread.Create(False);

          参数False表示,新线程myThread在创建后,将立即运行。如果想不立即运行,而是在另一个适当的时刻运行,则可以使用如下代码:

myThread := TMyThread.Create(True); 
……
myThread.Resume;  //适当的时刻启动该线程

2.2.2 新的线程在哪里工作

          在Delphi中,创建新线程时,通常的做法是从系统线程类TThread进行继承,该类有一个虚方法:

procedure Execute; virtual;

          在上文的TMyThread类中,重写了这个方法,如下所示:

TMyThread = class(TThread)
protected
    procedure Execute; override;
public
end;

          安排新线程做的工作任务,应该在这个方法中完成。

2.2.3 新的线程何时退出

          当方法Execute退出时,新线程就结束了。在下面的Execute方法中,它只是向屏幕打印了一个语句“I am a new thread”,新线程就结束了。

procedure TMyThread.Execute;
begin
    Writeln('I am a new thread');
end;

          这是新线程的正常退出方法。除此之外,Delphi没有提供立即终止新线程的方法,如Kill、Abort等其他语言提供的方法。若要立即杀死线程,则需要调用Win32 API方法TerminateThread(myThread.Handle, 0)。这是一种暴力退出方法,可能导致系统不稳定,因此严重不推荐。
          在TThread中,与线程暂停、退出有关的方法和属性有:

  • property Terminated: Boolean;
            Delphi解释:The thread's Execute method and any methods that Execute calls should check Terminated periodically and exit when it's true. The Terminate method sets the Terminated property to true。
            中文翻译:Execute方法以及它调用的任何方法都应该周期性地查看Terminated的值,一旦发现Terminated为True,就应该退出。Terminate方法将属性Terminated设为True。
            上述说法表明,将Terminated设为True,并不能退出线程,它只是告诉Execute方法,“有人让你们尽快完事,你们快点干”,但Execute可以不理会Terminated的值,仍然自顾自地运行。

  • property Suspended: Boolean;
            Delphi解释:Set Suspended to true to suspend a thread; set it to false to resume it. Suspended threads do not continue execution until they are resumed.
            中文翻译:设置Suspended为True以挂起(暂停)一个线程;设置它为False以唤醒(继续)一个线程。挂起的线程不会继续执行,直到它被唤醒为止。

  • procedure Terminate;
            Delphi解释:Terminate sets the thread’s Terminated property to true, signaling that the thread should be terminated as soon as possible.
            中文翻译:Terminate方法设置线程的Terminated属性为True,该信号表明线程应该尽快结束。
            上述文字表明,Terminate方法只是想Execute方法喊话,“喂,哥们,快点啊,时间不多了,快点干完”,Execute如果懂礼貌的话,它会时不时地注意是否有人让它停止干活,一旦收到停工的消息,它就会尽快收拾停当,如果它不懂礼貌的话,则会把停工的消息当作耳边风。

  • procedure Resume;
            Delphi解释:Call Resume to cause a suspended thread to start running again. Calls to Suspend can be nested; Resume must be called the same number of times Suspend was called before the thread will resume execution.
            中文翻译:调用Resume方法以让一个挂起(暂停)的线程重新开始运行。对Suspend方法的调用可以嵌套;在线程继续运行之前,调用Resume方法的次数必须与调用Suspend方法的次数相同。

  • procedure Suspend;
            Delphi解释:Call Suspend to temporarily halt execution of the thread. To resume execution after a call to Suspend, call Resume. Calls to Suspend can be nested; Resume must be called the same number of times Suspend was called before the thread will resume execution.
            中文翻译:调用Suspend方法临时中止线程的执行。若要在调用Suspend方法后继续执行,请调用Resume方法。对Suspend方法的调用可以嵌套;在线程继续运行之前,调用Resume方法的次数必须与调用Suspend方法的次数相同。

2.2.4 新线程如何销毁

          有两种方法:
          1. 在创建线程时,设置FreeOnTerminate为True,那么当Execute执行完毕时,系统自动销毁新线程。有如下几个地方,设置FreeOnTerminate为True。

  • 第一个地方——Create方法内部

      //为TMyThread提供Create方法,在Create方法中设置
      constructor TMyThread.Create;
      begin
          FreeOnTerminate := True;   //线程工作完毕后要自行销毁
          inherited Create(False);     //线程创建后立即启动
      end;
      //调用TMyThread.Create的地方,需要修改为
      procedure TForm1.FormCreate(Sender: TObject);
      begin
          myThread := TMyThread.Create;
      end;
    
  • 第二个方法——在Execute方法内部,执行工作任务之前

      procedure TMyThread.Execute;
      begin
          FreeOnTerminate := True;
          Writeln('I am a new thread');
      end;
    
  • 第三个方法——在类TMyThread的外部

      constructor TMyThread.Create;
      Begin 
          inherited     Create(True);     //线程创建后不立即启动
      end;
      //在TForm1内部,创建TMyThread线程后,设置FreeOnTerminate 为True
      procedure TForm1.FormCreate(Sender: TObject);
      begin
          myThread := TMyThread.Create;
          myThread.FreeOnTerminate := True;
      end;
    
      //在合适的地方,执行如下语句
      myThread.Resume;
    

由此可见,只需要在Execute退出前,设置FreeOnTerminate为True即可。

        2. 如果没有设置FreeOnTerminate为True,则需要在Execute执行完毕后,开发人员人为地销毁它,代码如下:

//主线程在适当的地方执行下述语句
FreeAndNil(myThread);

3. 可持续工作的线程

3.1 使用循环实现持续工作

        上文创建的线程,只做了一件事情(即向控制台输出一行文本),就退出了。显然,这种做法没有挖掘线程的价值。为了改变这种现象,需要在Execute方法写入一个循环。该循环通常是一个永真循环,即死循环;当某些条件为真(比如Terminated为True)时,退出死循环。循环的形式可以是while、for、repeat-until语句,退出循环的形式可以是break或Exit。这里以while和Exit为例,说明用法。
        第一步:在上文的项目中,将unitMyThread单元的代码改为:

unit unitMyThread;
interface
uses Windows, Classes, SysUtils;
type
    TMyThread = class(TThread)
    protected
        procedure Execute; override;
        procedure DoMyWorkByWhile;
    
    public
        constructor Create;
    end;

implementation

{ TMyThread }

constructor TMyThread.Create;
begin
    inherited Create(True);
end;

procedure TMyThread.DoMyWorkByWhile;
var totalCount: Integer;
begin
    totalCount := 0;
    while(True) do
    begin
        Inc(totalCount);
        Writeln('第' + IntToStr(totalCount) + '次循环 @' + FormatDateTime('yyyy-MM-dd HH:mm:ss', Now));
        Sleep(500);
    
        if(Terminated) then
        begin
          Exit;
        end;
    end;

    //上述循环也可以改为
    while(not Terminated) do
    begin
        Inc(totalCount);
        Writeln('第' + IntToStr(totalCount) + '次循环 @' + FormatDateTime('yyyy-MM-dd HH:mm:ss', Now));
        Sleep(500);
    end;
end;

procedure TMyThread.Execute;
begin 
    FreeOnTerminate := True;
    DoMyWorkByWhile;
end;

end.

        第二步:在TForm1主窗体上添加两个按钮,分别是btnStart(启动)和btnExit(退出),主窗体单元代码为:

unit unitMainForm;

interface

uses   Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,   Dialogs, unitMyThread, StdCtrls;

type
    TForm1 = class(TForm)
        btnStart: TButton;
        btnExit: TButton;
        procedure btnStartClick(Sender: TObject);
        procedure btnExitClick(Sender: TObject);
    private
            { Private declarations }
            myThread: TMyThread;
      public
            { Public declarations }
    end;

    var
            Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.btnStartClick(Sender: TObject);
begin
    myThread := TMyThread.Create;
    Writeln('亲亲的主人,谢谢您给了我以生命 @' +         FormatDateTime('yyyy-MM-dd HH:mm:ss', Now));
    //这里可以做很多其他工作
    myThread.Resume;
end;

procedure TForm1.btnExitClick(Sender: TObject);
begin
    if Assigned(myThread) then
    begin
        myThread.Terminate;  //不可以写作myThread.Terminated := True,因为Terminated不是public的
        Writeln('');
        Writeln('亲,永别了,来生再会 @' + FormatDateTime('yyyy-MM-dd HH:mm:ss', Now));
    end;
end;

end.

        第三步:点击启动,一会儿后,点击退出,运行结果如下:


图11

3.2 可暂停的线程

        第一步:在TForm1主窗体上添加一个按钮btnPause(暂停)和btnResume(继续),双击它增加一个事件处理方法,如下所示:

procedure TForm1.btnPauseClick(Sender: TObject);
begin
    if Assigned(myThread) then
    begin
        myThread.Suspend;
        Writeln('亲,你把我暂停了 @'  + FormatDateTime('yyyy-MM-dd HH:mm:ss', Now));
    end;
end;

procedure TForm1.btnResumeClick(Sender: TObject);
begin
    if Assigned(myThread) then
    begin
        myThread.Resume;
        Writeln('');
        Writeln('亲,你把我唤醒了,我还没睡够呢 @'  + FormatDateTime('yyyy-MM-dd HH:mm:ss', Now));
    end;
end;

        第二步:点击启动,一会儿,点击暂停,一会儿,点击继续,一会儿,点击退出,运行结果如下:


图12

3.3 可空转/继续工作的线程

        在3.2节中,我们让线程实现了挂起(暂停)和唤醒(继续)两个操作,对某些场合来说很有用,但仍然无法某些场景的需求,举例如下:
        令狐冲因为跟魔教有勾结,被师傅岳不群罚去洗碗,包一日三餐,早上5:00开始上班,晚上11:00休息,中间不允许休息。令狐冲起床后,就要站在洗碗流水线上,他要做3件事情:1)观察是不是有碗筷要洗;2)如果有碗筷要洗,则刷洗碗筷;3)观察是不是洗完了。
        上述场景,用Suspend和Resume是解决不了的。为什么这么说呢?表面上,正在洗碗的动作,表示的是Resumed状态,这没错,而没有洗碗动作的时候,貌似是Suspended状态,这就错了,其实这也是Resumed状态。原因在于,若一个线程处于Suspended状态,就相当于令狐冲在睡觉,在睡眠中他是无法观察任何外界现象的。因此,实际上,上述三件事情,线程都必须在Resumed状态。
        第一步:在unitMyThread单元的类TMyThread中增加一个public字段:

Working: Boolean;

        第二步:在TMyThread.Create中初始化:

Working := True;

        第三步:增加洗碗方法TMyThread.WashDishes,如下所示:

procedure TMyThread.WashDishes;
var totalCount: Integer;
begin
    totalCount := 0;

    while(not Terminated) do
    begin
        while(Working) do  //观察是否洗完了,Working为True说明还没洗完
        begin
            Inc(totalCount);
            Writeln('老板,我洗了第' + IntToStr(totalCount) + '个碗 @' + FormatDateTime('yyyy-MM-dd HH:mm:ss', Now));
            Sleep(500);  //洗一个碗,歇500毫秒
        end;
        //洗完了
        Sleep(2000);  //每隔2秒钟,观察是否有新的一波碗要洗
    end;
end;

        第四步:修改TMyThread.Execute方法,如下所示:

procedure TMyThread.Execute;
begin
    FreeOnTerminate := True;
    //DoMyWorkByWhile;
    WashDishes;
end;

        第五步:在TForm1主窗体上增加按钮btnStartWash(洗碗)和btnSleepAwhile(歇会儿),增加两个事件方法,如下所示:

procedure TForm1.btnStartWashClick(Sender: TObject);
begin
    if Assigned(myThread) then
    begin
        Writeln('老板,从哪儿弄来这么多碗,生意不错啊,我要开洗了 @'  + FormatDateTime('yyyy-MM-dd HH:mm:ss', Now));
        myThread.Working := True;
    end;
end;

procedure TForm1.btnSleepAwhileClick(Sender: TObject);
begin
    if Assigned(myThread) then
    begin                                                                                 
        myThread.Working := False;
        Writeln('老板,我洗完了,歇会儿啊 @'  + FormatDateTime('yyyy-MM-dd HH:mm:ss', Now));
    end;
end;

        第六步:点击启动→洗碗→歇会儿,结果如下:
图13

4 与主线程通信

        在上文中,工作线程只是自顾自地干活(即向控制台输出文本),它并没有将工作进度实时报告给主线程。
线程通信有很多实现方式,有些复杂,有些简单。这里主要提供两种思路和实现。

4.1 主线程循环查询

        在主线程中增加一个时钟Timer1和OnTimer事件的处理方法Timer1Timer(Sender: TObject),在这个方法中,主线程循环查询工作线程的内部状态。
        第一步:在TMyThread中增加一个public字段:

DishNumber: Integer;   //表示总共洗了多少个碗

        第二步:在TMyThread.Create方法中增加一个语句:

DishNumber := 0;

        第三步:在TMyThread.WashDishes方法中的Writeln上方增加一条语句:

DishNumber := totalCount;

        第四步:在TForm1主窗体上增加一个标签lblDishNumber(洗碗个数)和文本框edtDishNumber。
        第五步:在Timer1Timer方法中增加语句:

edtDishNumber.Text := IntToStr(myThread.DishNumber);

        第六步:运行程序,点击启动→洗碗→歇会儿,结果如下:


图14

4.2 工作线程回调

        第一步:在TMyThread中增加一个public字段:

Callback: TNotifyEvent;

        第二步:在TMyThread.WashDishes中的Writeln上方增加一条语句:

Callback(Self);

        第三步:在TForm1中增加一个方法TForm1.callbackByMyThread(Sender: TObject),如下所示:

procedure TForm1.callbackByMyThread(Sender: TObject);
begin
    if Assigned(myThread) then
    begin
        edtDishNumber.Text := IntToStr(myThread.DishNumber);
    end;
end;

        第四步:在TForm1.btnStartClick(Sender: TObject)中的Writeln上方增加一个语句:

myThread.Callback := callbackByMyThread;   //设置回调方法

        第五步:在TForm1.btnStartClick(Sender: TObject)中的Writeln上方增加一个语句:

Timer1.Enabled := False;                   //禁止时钟

        第六步:运行程序,点击启动→洗碗→歇会儿,结果如下:


图15

4.3 两种通信方法的缺点

        如下所示:

优缺点主线程循环查询工作线程回调
优点可以方便访问窗体控件,无需线程切换实时性有保证
缺点实时性难以保证需要切换线程,在访问窗体控件时需要线程同步

        在实时性方面,举一个比喻来说明问题。

        岳不群派遣令狐冲带小师妹岳灵珊攻占黑木崖,但岳不群又不放心,为保险起见,他决定采取打电话循环查询的方式,他这么做:

第一个夜晚:岳不群打电话:“冲儿,攻占黑木崖了吗?”
令狐冲回道:“师傅,没呢,还在路上。”

第二个夜晚:岳不群打电话:“冲儿,攻占黑木崖了吗?”
令狐冲回道:“师傅,没呢,还在路上。”
……

第1000个夜晚:岳不群打电话:“冲儿,攻占黑木崖了吗?”
令狐冲回道:“师傅,没呢,还在路上。”

第1000 + 1个夜晚:岳不群打电话:“冲儿,攻占黑木崖了吗?”
令狐冲回道:“师傅,攻占了,但是师妹被东方不败抢走了。”
岳不群:“完了,完了,给我立即追击,要是找不到姗儿,你就别回来了。”

        在这1001个夜晚,岳不群茶饭不思、心神不灵,干啥啥不成,睡啥啥不香,还不如亲自带着自己的小师妹宁中则攻占黑木崖呢。令狐冲也过得不爽,每天晚上都要接一次电话,简直没法跟小师妹说悄悄话了和做其他事情了。特别是,要是早上9:00攻占了黑木崖,还不能立即告诉师傅好消息,只能等到晚上师傅打电话过来。

        由于师妹被东方不败抢走了,据说带到扶桑岛去了,令狐冲决定趁胜追击,但是路途遥远,路上信号又不好,关键是手机用了将近三年,电池不行啊,撑不住每天一个电话,于是,第1002个夜晚,令狐冲突发奇想,给师傅打了个电话,说道:“师傅,东方不败虏着师妹逃到扶桑去了,我要去追她,但手机电池不行了,路上充电不方便,所以,以后您就别打电话问我了,一旦有情况,我给您打电话。”
        岳不群:“好的,冲儿,如此甚好,能省不少电话费。”

        一路上,令狐冲为了省电,将手机关机。岳不群不用打电话问令狐冲了,每天带着宁中则用心训练其他徒弟,以便随时增援令狐冲。

第1100个夜晚,岳不群收到令狐冲来电:“师傅,我到了山东半岛入海口,已经雇佣好了民船。”
岳不群:“冲儿,别坐民船了,到青岛机场坐飞机过去。”
令狐冲:“师傅,我没钱了。”
岳不群:“叫你师娘给你微信转账10万块。”

        第1101个夜晚,令狐冲在扶桑下了飞机,恰巧看到东方不败也带着小师妹下了飞机,令狐冲赶紧给师傅打电话:“师傅,我看到东方不败和小师妹了,我立即去收拾他。”
        岳不群:“好,小心点,一定要把姗儿救回来。”

        从两个例子看出,回调的方法,其实时性要好于循环查询。

        但是,回调方法有一个缺点,就是不能直接在回调方法中访问窗体控件,其原因为:窗体控件都是由主线程创建的(其他线程也可以创建窗体,但这里假设只有主窗体创建了窗体),Delphi运行时库为了安全性,不允许主线程以外的线程访问和修改窗体控件,否则会引发一些隐患,很难跟踪调试。
        不过,由于Delphi7的运行时库并不是很严谨,因此有时候工作线程也能修改窗体控件,Delphi7不报错,例如上述TForm1.callbackByMyThread方法就在线程myThread中允许,它修改了edtDishNumber.Text。尽管如此,但Delphi7对这种操作的可靠性、稳定性不予以任何保证。
        那怎么办呢?采用线程同步的方法。线程同步有很多方式,这里采用较为简单的一种,即线程切换。具体做法是:
        第一步:在TForm1中增加一个无参数方法,如下所示:

procedure TForm1.dealAfterCallbackByMyThread;
begin
    edtDishNumber.Text := IntToStr(myThread.DishNumber);
end;

        第二步:将TForm1.callbackByMyThread修改为:

procedure TForm1.callbackByMyThread(Sender: TObject);
begin
    if Assigned(myThread) then
    begin
        TThread.Synchronize(nil, dealAfterCallbackByMyThread);
    end;
end;

        在上述代码中,调用类TThread的静态方法,就可以从线程myThread切换到主线程。具体地说,方法TForm1.callbackByMyThread运行在线程myThread上,线程myThread通过调用方法TThread.Synchronize,将方法放到主线程上,并立即切换到主线程,主线程且立即执行dealAfterCallbackByMyThread。

        第三步:运行程序,点击启动→洗碗→歇会儿,结果如下:


图16

4.4 回调方法可能存在的固有缺陷

        细心的童鞋们,肯定发现了一个问题,那就是上图中的时间有问题,不再是按照500毫秒的间隔更新,而是隔了好几秒,实时性更差了。这是为什么呢?
        这个现象也让我百思不得其解,我用了以下方法去寻找原因:
        1)死锁:找了半天,也没有找到死锁的地方。
        2)Synchronize用法不对:找了很多地方,发现大家都是这么用的。
        3)到国外网站查看:没有搜索到相同问题的描述
        4)将程序拷贝到Win10,运行良好,如下所示:


图17

        我冥思苦想,手脚晃荡,无意中,我发现了一个问题,那就是在XP系统中,当我鼠标在TForm1窗体上晃动时,程序马上有输出。
        这是什么原因呢?我分析如下,不知对错,请大家指正:
        1)方法TForm1.callbackByMyThread运行在线程myThread上,在该方法内部,线程myThread通过调用方法TThread.Synchronize,先是给主线程发一个空的PostMessage消息,激活主线程。
        2)myThread然后给主线程发送一个SendMessage,消息告诉主线程调用dealAfterCallbackByMyThread。
        3)然后myThread挂起线程myThread,等待主线程回复。
        4)主线程在适当的时候执行dealAfterCallbackByMyThread。
        5)主线程执行dealAfterCallbackByMyThread完毕后,告诉线程myThread,线程myThread继续运行。

        上述过程的一个关键地方就是“主线程在适当的时候”,什么时候才算是适当的呢?互联网上很多文章说,主线程在空闲的时候会执行dealAfterCallbackByMyThread。这就麻烦了,主线程有时候很忙的,日理万机,不知道什么时候能闲下来,没空理会myThread,这就会导致myThread发生阻塞,从而没法好好干活。

        经过我的研究发现,“主线程在空闲的时候”是不准确的,至少在XP系统中是这样。上面我提到过,在XP系统中,程序实时输出内容到控制台,但只要鼠标在TForm1窗体上晃动,程序就会马上更新输出,因此,这说明恰恰是“主线程在忙的时候(处理鼠标晃动消息)”才会理会线程myThread的消息。照着这个思路,我再说一下上述过程:

        1)方法TForm1.callbackByMyThread运行在线程myThread上,在该方法内部,线程myThread通过调用方法TThread.Synchronize,先是给主线程发一个空的PostMessage消息(WM_NULL),试图激活主线程。但是,由于PostMessage发的是空消息,所以主线程没有处理,即使此时主线程很空闲,它也懒得处理空消息。也可以简单理解为,主线程实际上没有激活。
        2)myThread然后给主线程发送一个SendMessage,消息告诉主线程调用dealAfterCallbackByMyThread。此时,主线程收到了SendMessage发来的消息,但是因为主线程没有理会myThread通过PostMessage发送的消息,自然也就不会理会SendMessage的消息。凡事总有一个先来后到,前面的还没处理呢,后面的咋处理呢?
        3)然后myThread挂起线程myThread,等待主线程回复。主线程这个时候正闲着呢,才懒得回复呢。
        4)上帝移动了一下鼠标,主线程收到了上帝的命令,立即开始干活,先是处理上帝的命令(注意,Windows消息有优先级别,来自用户也就是上帝的消息,通常有较高的优先级),完毕后,发现角落里还藏着myThread发来的消息,于是顺便处理,马上执行dealAfterCallbackByMyThread。
        5)主线程执行dealAfterCallbackByMyThread完毕后,告诉线程myThread,事情处理完了,线程myThread继续运行。

        上述说辞似乎解决了问题,用的是时钟方法。但是,上帝总不能时时刻刻去移动鼠标啊,那还不如让岳不群每天打一个电话呢。
        上帝总是万能的,于是上帝在TForm1.Create方法中,又启动了时钟,且为了及时处理myThread的消息,时钟的间隔得比myThread.Execute中的休息间隔500毫秒还短。为了保证较好的实时性,将时钟间隔设为100毫秒。于是,每隔100毫秒,主线程收到了一条必须马上处理的时钟消息,处理完后往角落里看两眼,若是有myThread的消息,就马上处理,若是没有,则继续睡100毫秒小憩。
        更改代码后,在XP中重新运行,结果如下:


图18

        可见,上述结果是正常的。
        对于这个问题,我不知道这算不算Delphi7的缺陷或是XP系统的缺陷,也不知道我上面的解释是否正确,请大家指正。

4.5 回调方法就没有用了吗?

        在4.4节中,我们在使用回调方法进行线程通信时,出现了问题,为了解决问题,又使用了基于时钟的查询方法。这是否说明回调方法不但毫无用处呢,还更费事呢?
        也不能这么说,我举一个例子,说明一下。还是以岳不群、令狐冲为例。

        令狐冲带着小师妹去攻打黑木崖,临行前,岳不群嘱咐道:“冲儿,你独孤九剑已经达到炉火纯青的地步,远超为师了,你就放心地去收拾东方不败吧,有啥事你打个电话,没啥事我就跟你师娘唱唱歌、吟吟诗。”令狐冲答应照办。
        (也就是说,两人商量以回调的方式来通信。)

        走到半路上,令狐冲和小师妹突然遇到东方不败派来的四大护法,四大护法练就了一个天罡北斗阵,令狐冲苦战得脱,幸好小师妹毫发无损。
        (也就是说,工作线程完成了一个任务。)

        作战毕,令狐冲给岳不群打了个电话,但岳不群忙着呢,没接着,于是令狐冲只好发了微信,然后就抱着小师妹在路边歇着,等着师傅下一个指示。
        (也就是是,工作线程给主线程发了一个消息,然后把自己挂起来,等待主线程的回复。)

        但是,岳不群的微信好友太多,消息太多,没有把令狐冲的消息当回事,也就没有处理令狐冲的消息。
        (也就是说,主线程没有理会工作线程发来的空消息和其他消息。)

        幸好,岳不群有一个抽烟的习惯,他一般是10分钟抽一根,一根烟抽10分钟,然后干别的事情。在抽烟的过程中,岳不群啥事不干,就是把所有的未读微信消息看个遍,很快就看到了令狐冲的消息,于是顺便回复了一句:“冲儿,干得漂亮,天罡北斗阵还是蛮霸道的,上次差点让为师和师娘回不来了。”
        (抽烟的事件相当于时钟消息。)

        在上述岳不群和令狐冲的例子中,如果只有基于抽烟的循环查询,那么岳不群每抽一根烟,都要打电话问一下令狐冲,“冲儿,现在走到哪里了?情况如何?”可以想象,岳不群这个烟抽得肯定不爽。
        但是,若在抽烟的同时,看看有没有令狐冲的回调消息,如果有令狐冲的消息,就处理一下,没有的话,就看看左冷禅等群友最近在哪里发财,然后问问能不能带上自己。可以想象,这种情调下的抽烟,那才叫吞云吐雾般的享受。

        另外,再说明一下,如果只有基于时钟消息的循环查询,那么若工作线程没有更新,则每次查询时都得到同样的工作状态,这是正常现象。但是,如果规定,对于工作线程的每次状态,主线程只能用一次,那么基于时钟消息的循环查询,在工作线程没有更新状态的时候,就完全无法遵守规定。
为了好理解,这里举例说明。

        令狐冲是打牌高手,岳不群要给岳灵珊和令狐冲准备嫁妆,但没钱,于是派令狐冲去澳门赌坊弄点钱。两人约定,令狐冲每天生活费要1000元,出发前岳不群只给令狐冲一天的生活费,令狐冲每局从牌桌上能赢得至少0元,赢来的钱马上存到银行卡里,岳不群知道令狐冲的银行卡号,他每隔30分钟从令狐冲的卡里划1000元到自己的卡里。令狐冲由于要集中精力打牌,因此不管输赢,都不会打电话告诉岳不群。

        大家想想,岳不群有没有可能把令狐冲的生活费划走?
        有些人觉得不会,有些觉得会。注意上面的约定,并未包括“岳不群在划账之前要检测一下令狐冲银行卡里面的钱够不够”。为什么不包括呢?因为令狐冲有自己的隐私,不愿意让岳不群检查自己的钱包(也就是说,对象的封装性,决定了对象必须封装一些内部状态,不让外部读取。)因此,如果令狐冲手气不好,有好几局没赢到钱,岳不群肯定会把他的生活费划走的。
        如果两人加一条约定,就可以解决上述问题。

        令狐冲:“师傅,每次赢了超过1000块钱,我就给您发条微信,告诉您赢了多少,您有空的时候就处理一下。”(注意:最开始的时候,令狐冲有1000块钱,在赌博开始前,他是不会给岳不群发消息的。)
        岳不群:“此计甚好。不过,我也有自己的事情,半个小时处理一下(相当于时钟消息),若正好在看微信(相当于在窗体上移动鼠标),我就马上处理。”

        可见,令狐冲每次有更新的时候,就把更新的状态(新赢到的钱)通过回调(微信消息)告诉岳不群,岳不群在主线程中通过微信把新赢到的钱转走,但对于令狐冲那1000块钱生活费,因为它不是新的变化,岳不群即使看到了也不会去处理。

        再举一个例子,电脑通过COM口连接了一个扫码枪,扫码枪收到一个条形码(比如“69123432432”)后,就存在内部,然后通过回调告诉电脑,电脑在回调里处理这个码。电脑同时运行一个时钟,假设周期是1秒。如果没有回调方法,则电脑只能在时钟事件里去处理条形码“69123432432”,算出当前总价,处理完后,下一个1秒钟,电脑又看到了条形码“69123432432”,此时就有了疑问,这是上一个处理过的商品,还是顾客又扫了同一个商品?这时就很难区分了。
        对于这种情况,有些童鞋会说,电脑可以在用完“69123432432”之后,电脑让扫码枪删除内部保存的“69123432432”。在下一个1秒钟,如果顾客没有扫描商品,则码是空的,如果顾客扫描了商品,即使仍然是同一个“69123432432”,电脑也能够安全地使用它。
        但是,不要忘了,电脑和扫码枪是两个独立的线程,电脑线程让扫码枪删除“69123432432”,但扫码枪线程可能同时新收到顾客扫描的“69123432432”,那么,此时就会产生资源争用问题。
        如果在扫码枪的回调方法里处理条形码“69123432432”,问题就好办了。由于扫码枪仅仅在收到新的条形码后才会进行回调,因此能确保每个条形码能被处理一次,且仅被处理一次。

5 结论

        本文简单地讨论了Delphi中的多线程编程,内容基础、详实,但是,限于作者水平不高,可能有诸多错误的地方,请大家批评指正。

6 做点广告

        各位Delphi码农朋友们,作为一个Delphi码农,我与大家一样,码砖赚钱不容易,所以我业余还做点副业,讨个生活,就是做竹妃纸的个人营销,请大家支持。凡是给出实际行动支持的,我都发源代码。
        竹妃纸,是目前很火的一种天然环保用纸,据说是可以吃的原浆纸,健康无毒环保,特别适合家庭有小孩的朋友们。若想了解实际情况,请大家使用以下二维码,照着以下步骤操作。
        1. 第一步,我的竹妃二维码,请大家下载到微信里。


图19

        2. 第二步,点击图片以便让其满屏,然后单指按住它达到3秒钟,弹出如下图所示的快捷菜单。


图20

        3. 第三步,点击上图中的“识别图中二维码”,稍等一会儿,就会弹出如下界面。如果网速慢,则要多等一会儿。
图21

        4. 第四步,再次单指按住上图达到3秒钟,弹出如下图所示的快捷菜单。
图22

        5. 第五步,点击上图中的“识别图中二维码”,进入如下界面。


图23

        6. 第六步,在上图中点击“关注”,进入如下界面:
图24

        7. 第七步,点击上图左下角的“进入商城”,如下所示:
图25

        选择您最需要的一款产品,点击“立即购买”,然后按照指示操作,直到付款成功。其余的操作,都是大家熟悉的界面,我就不再赘述了。如果有不会的,可以加我的微信好友,既可以交流技术问题,也可以交流竹妃纸的使用心得。

        我的微信二维码是:


图26

        感谢各位Delphi朋友,Delphi码农日子不容易啊,期待各位同行支持一下我,万分感谢!

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页