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码农日子不容易啊，期待各位同行支持一下我，万分感谢！