线程杂谈2_while not terminate do-优快云博客

本文链接：https://blog.youkuaiyun.com/linzhengqun/article/details/593229

本文探讨了如何优雅地终止线程以及线程间的同步机制，包括使用线程类的Terminated属性和WaitFor方法来确保线程资源的正确释放，以及通过临界区（CriticalSection）来保护多线程环境下的数据一致性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

作者:linzhenqun(风)

时间: 2006-2-6

Blog: http://blog.youkuaiyun.com/linzhengqun

-----------------------------------------------------------------------------------------------------

前言

上次写了一篇关于线程的文章，其中有介绍当工作线程有资源存在时，主线程如何释放工作线程的方法，后来仔细读了《Win32多线程程序设计》，对于线程的机制有了更进一步的理解，才知道那并非最佳的方法，这里将给出一个更好的方法，这也是我写这篇文章的最大原因。另外，对于同步机制也将作一些探讨。如果想全面了解多线程的，推荐看候捷翻译的《Win32多线程程序设计》。

干净地终止一个线程

回到上一篇的问题描述：如果线程中有一些资源，Execute正在使用这些资源，而主线程要释放这个线程，这个线程在释放的过程中会释放掉资源。想想会不会有问题呢，两个线程，一个在使用资源，一个在释放资源，会出现什么情况呢。具体的情况请看“线程杂谈”那篇文章。总之是出现了违法访问，而我给出的解决方法是使用一个FFinished成员，最后释放的时候循环判断FFinished，这样可以保证Execute执行完毕之前，线程的成员类不会被释放。利用线程类的Terminated属性和FFinished成员,便可在主线程干净结束工作线程。

但这并非最好的解决方法，循环判断FFinished成员即如下：

While not FFinished do

Sleep(100);

这并不能即时释放线程，最慢的情况还要等上0.1秒才能释放。而如果我们使用下面这种形式：

While not FFinished do

;

则是一种典型的Busy loop，主线程不停的使用While循环，非常浪费CPU的资源，这样的效率比直接等待慢一倍以上。

那么有没有一种方法，让主线程通知工作线程可以结束了，然后主线程等待工作线程结束，工作线程结束后才释放资源呢？让主线程通知工作线程结束可以用线程类的Terminated属性，这一点在上一篇文章已有介绍。而主线程等待Execute结束，事实上线程类的Destroy方法已经有这样的机制：

Terminate;

...

WaitFor;

其中的WaitFor方法一直等待直到Execute方法执行完毕（准确的说应该是ThreadProc函数执行完毕）。这些代码在一般的线程类中已经够用了，但有些线程类有自己的类成员，并会覆盖Destroy方法，在其中释放类成员，既然这样，我们可以把上面的代码包成一个方法，并在自己的Destroy中首先调用该方法。这样即可即时干净地释放线程类，比使用循环更好。

下面给出例子：

unit Unit1;

interface

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

type
  TMyClass = class
  private
    FTest: Integer;
  public
    procedure test;
  end;

  TMyThread = class(TThread)
  private
    FMyClass: TMyClass;
  protected
    (* 等待Execute方法执行完毕 *)
    procedure WaitExecute;
    procedure Execute; override;
  public
    constructor Create(CreateSuspended: Boolean);
    destructor Destroy; override;
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
    procedure OnTerminate(Sender: TObject);
  public
    { Public declarations }
    MyThread: TMyThread;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TMyThread }

constructor TMyThread.Create(CreateSuspended: Boolean);
begin
  inherited;
  FMyClass := TMyClass.Create;
end;

destructor TMyThread.Destroy;
begin
  WaitExecute;
  FMyClass.Free;
  FMyClass := nil;
  inherited;
end;

procedure TMyThread.Execute;
begin
  while not Terminated do
    FMyClass.test;
end;

procedure TMyThread.WaitExecute;
begin
  Terminate;
  WaitFor;
end;

{ TMyClass }

procedure TMyClass.test;
begin
  //用Sleep模拟业务操作
  Sleep(100);
  FTest := 0;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  MyThread := TMyThread.Create(False);
  MyThread.OnTerminate := OnTerminate;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  MyThread.Free;
end;

procedure TForm1.OnTerminate(Sender: TObject);
begin
  ShowMessage('OK');
end;

end.

先点击Button1，然后点击Button2，线程类可以被正确地释放，试着把Destroy方法中的WaitExecute方法注释掉再点击按钮，接着关闭程序看看，这时就出现违法访问了。

同步机制

当有多个线程同时读写一个资源时，使用同步机制可以保护数据的完整性，也可以防止数据被损坏。线程同步有很多种方式，但最常用的还是临界区（Critical Sections），这里只讨论临界区。不过之前，先说明一下同步（Synchronous）和异步（Asynchronous）的概念。当程序1调用程序2时，程序1停止不动，直到程序2完成回到程序1来，程序1才继续下去，这就是同步；如果程序1调用程序2后，自己继续执行下去，那么两者之间就是异步。很明显多线程是一种异步执行方式，Windows系统的SendMessage和PostMessage分别是同步和异步方式。

一个TRTLCriticalSection类型的变量代表了一个临界区，引用《Windows高级编程》中的话，临界区就好像一个只能进一人的洗手间，后面的人只能排队等到进去的人出来才能进去。让我讲得详细一点，假设你有一个数据结构A会被线程B和C读写，则你可以声明一个TRTLCriticalSection变量CS，接着调用InitializeCriticalSection(CS)，这时你拥有了一个临界区，在B和C线程对A进行读写的地方，都套上如下的代码：

EnterCriticalSection(CS);

try

//对A进行读写

finally

LeaveCriticalSection(CS);

end;

你便能保证同一时间只有一个线程对A进行读写。

它的过程是这样的：

线程B和C一直在运行，某一时刻，B和C同时要对A进行操作，但事实上是不可能同时的，总有一个线程会快一点，假设是B吧，B线程的第一句便是EnterCriticalSection(CS)，使得线程B进入了临界区，接着B对A进行操作。而操作系统总是这样频繁的在不同线程之间切换以制造“多任务”的假象，当B对A的操作进行到一半时，系统将执行权切换给线程C，我们知道C也要对A进行操作，它的第一句也是EnterCriticalSection(CS)，可是进这个“洗手间”时发现里面已经有“人”了，C没办法只能一直停在Enter的地方等候，过很短的时间，执行权交给了线程B，B继续对A进行操作，如此反复，B终于操作完了，最后调用LeaveCriticalSection(CS)离开“洗手间”，这时执行权再交到C时，C发现B已经离开临界区，它终于可以进入临界区对于A进行操作了，而此时别的线程要对A进行操作，也只能等C离开“洗手间”。

对于临界区有些地方值得注意：

1. 一个TRTLCriticalSection变量代表一个临界区，如果你使用两个这样的变量，则它们是毫不相干的，就像两个“洗手间”一样，对于同一个资源不能起到同步的作用。

2. 不要针对多个资源只声明一个Critical Section，这样使每一时刻只能对一个资源进行读写，会对程序的效率有很大的影响。为每个需要同步保护的资源声明一个临界区变量。

3. 需要对资源进行同步保护，则所有对资源操作的地方都要有Enter和Leave函数，且要有Try..finally结构，保证最后能Leave。

4. 在临界区里面不要进行非常费时的操作，更重要的防止死锁的发生。

死锁

线程同步虽好，但也带来一些问题，最典型的就是死锁，死锁通常发生在线程之间相互等待的情况下。拿临界区来说，假设有两个临界区，两个线程分别进入一个临界区，接着各自又要进入另一个临界区，这时就会落入“你等我，我等你”的轮回。下面我制造这种场景给你给看看：

unit Unit1;

interface

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

const
  WM_MYMESSAGE = WM_USER + 001;

type
  TMyThread1 = class(TThread)
  protected
    procedure Execute; override;
  end;

  TMyThread2 = class(TThread)
  protected
    procedure Execute; override;
  end;

  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private
    { Private declarations }
  public
    { Public declarations }
    Thd1: TMyThread1;
    Thd2: TMyThread2;
  end;

var
  Form1: TForm1;
  CS1, CS2: TRTLCriticalSection;
implementation

{$R *.dfm}

procedure DeadLock(var CSA, CSB: TRTLCriticalSection);
begin
  EnterCriticalSection(CSA);
   Sleep(100);
  EnterCriticalSection(CSB);
  try
    Sleep(1000);
  finally
    LeaveCriticalSection(CSA);
    LeaveCriticalSection(CSB);
  end;
end;

{ TMyThread }

procedure TMyThread1.Execute;
begin
  DeadLock(CS1, CS2);
end;

{ TMyThread2 }

procedure TMyThread2.Execute;
begin
  DeadLock(CS2, CS1);
end;

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
begin
  Thd1.Resume;
  Thd2.Resume;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  InitializeCriticalSection(CS1);
  InitializeCriticalSection(CS2);
  Thd1 := TMyThread1.Create(True);
  Thd2 := TMyThread2.Create(True);
end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  DeleteCriticalSection(CS1);
  DeleteCriticalSection(CS2);
  Thd1.Free;
  Thd2.Free;
end;

end.

运行上面程序，点击按钮1，你的程序没有什么异样，但关闭程序看看，程序关闭不了，因为两个线程落到相互等待的局面，而线程的Free又在等Execute结束，所以程序没有办法关闭了。

让我说说为什么会发生死锁，点击Button1时，两个线程同时启动，TMyThread1执行了DeadLock(CS1, CS2)，而TMyThread2执行了DeadLock(CS2, CS1)，注意到两个参数倒过来了。

它的过程是这样，首先线程1先执行DeadLock，第一个进入EnterCriticalSection(CSA)，注意这里的CSA是CS1，接下来Sleep(100)，在线程1睡觉到一般时，线程2得到执行权也执行DeadLock，它也进入EnterCriticalSection(CSA)，这里的CSA却是CS2，接着线程2也Sleep(100)，也是睡到一半，换到线程1，线程1睡醒后往下执行，它要Enter到CSB，对于线程1来说，CSB是CS2，但CS2已经被线程2给Enter了，所以线程1挂起等待线程2离开CS2临界区；接着线程2醒来要进入EnterCriticalSection(CSB)，这里的CSB是CS1，但CS1给线程1进入了，所以线程2也挂起等待线程1离开CS1临界区。就这样，两个线程相互等待，没完没了。