课题_Delphi中线程类TThread 实现多线程编程

Delphi中线程类TThread 实现多线程编程

Delphi中有一个线程类TThread是用来实现多线程编程的,这个绝大多数Delphi书藉都有说到,但基本上都是对TThread类的几个成员作一简单介绍,再说明一下Execute的实现和Synchronize的用法就完了.然而这并不是多线程编程的全部,我写此文的目的在于对此作一个补充.

线程本质上是进程中一段并发运行的代码.一个进程至少有一个线程,即所谓的主线程.同时还可以有多个子线程.当一个进程中用到超过一个线程时,就是所谓的"多线程".

那么这个所谓的"一段代码"是如何定义的呢?其实就是一个函数或过程(对Delphi而言).

如果用Windows API来创建线程的话,是通过一个叫做CreateThread的API函数来实现的,它的定义为:

HANDLE CreateThread(

LPSECURITY_ATTRIBUTES lpThreadAttributes, //线程属性(用于在NT下进行线程的安全属性设置,在9X下无效),

DWORD dwStackSize, //堆栈大小

LPTHREAD_START_ROUTINE lpStartAddress, //起始地址

LPVOID lpParameter, //参数

DWORD dwCreationFlags, //创建标志(用于设置线程创建时的状态)

LPDWORD lpThreadId 线程ID

);

最后返回线程Handle.其中的起始地址就是线程函数的入口,直至线程函数结束,线程也就结束了.

因为CreateThread参数很多,而且是Windows的API,所以在C Runtime Library里提供了一个通用的线程函数(理论上可以在任何支持线程的OS中使用):

unsigned long _beginthread(void (_USERENTRY *__start)(void *), unsigned __stksize, void *__arg);

Delphi也提供了一个相同功能的类似函数:

function BeginThread(

SecurityAttributes: Pointer;

StackSize: LongWord;

ThreadFunc: TThreadFunc;

Parameter: Pointer;

CreationFlags: LongWord;

var ThreadId: LongWord

): Integer;

这三个函数的功能是基本相同的,它们都是将线程函数中的代码放到一个独立的线程中执行.线程函数与一般函数的最大不同在于,线程函数一启动,这三个线程启动函数就返回了,主线程继续向下执行,而线程函数在一个独立的线程中执行,它要执行多久,什么时候返回,主线程是不管也不知道的.

正常情况下,线程函数返回后,线程就终止了.但也有其它方式:

Windows API:

VOID ExitThread( DWORD dwExitCode );

C Runtime Library:

void _endthread(void);

Delphi Runtime Library:

procedure EndThread(ExitCode: Integer);

为了记录一些必要的线程数据(状态/属性等),OS会为线程创建一个内部Object,如在Windows中那个Handle便是这个内部Object的Handle,所以在线程结束的时候还应该释放这个Object.

虽然说用API或RTL(Runtime Library)已经可以很方便地进行多线程编程了,但是还是需要进行较多的细节处理,为此Delphi在Classes单元中对线程作了一个较好的封装,这就是VCL的线程类:TThread

使用这个类也很简单,大多数的Delphi书籍都有说,基本用法是:先从TThread派生一个自己的线程类(因为TThread是一个抽象类,不能生成实例),然后是Override抽象方法:Execute(这就是线程函数,也就是在线程中执行的代码部分),如果需要用到可视VCL对象,还需要通过Synchronize过程进行.关于之方面的具体细节,这里不再赘述,请参考相关书籍.

本文接下来要讨论的是TThread类是如何对线程进行封装的,也就是深入研究一下TThread类的实现.因为只是真正地了解了它,才更好地使用它.

下面是DELPHI7中TThread类的声明(本文只讨论在Windows平台下的实现,所以去掉了所有有关Linux平台部分的代码):

TThread = class

private

FHandle: THandle;

FThreadID: THandle;

FCreateSuspended: Boolean;

FTerminated: Boolean;

FSuspended: Boolean;

FFreeOnTerminate: Boolean;

FFinished: Boolean;

FReturnValue: Integer;

FOnTerminate: TNotifyEvent;

FSynchronize: TSynchronizeRecord;

FFatalException: TObject;

procedure CallOnTerminate;

class procedure Synchronize(ASyncRec: PSynchronizeRecord); overload;

function GetPriority: TThreadPriority;

procedure SetPriority(Value: TThreadPriority);

procedure SetSuspended(Value: Boolean);

protected

procedure CheckThreadError(ErrCode: Integer); overload;

procedure CheckThreadError(Success: Boolean); overload;

procedure DoTerminate; virtual;

procedure Execute; virtual; abstract;

procedure Synchronize(Method: TThreadMethod); overload;

property ReturnValue: Integer read FReturnValue write FReturnValue;

property Terminated: Boolean read FTerminated;

public

constructor Create(CreateSuspended: Boolean);

destructor Destroy; override;

procedure AfterConstruction; override;

procedure Resume;

procedure Suspend;

procedure Terminate;

function WaitFor: LongWord;

class procedure Synchronize(AThread: TThread; AMethod: TThreadMethod); overload;

class procedure StaticSynchronize(AThread: TThread; AMethod: TThreadMethod);

property FatalException: TObject read FFatalException;

property FreeOnTerminate: Boolean read FFreeOnTerminate write FFreeOnTerminate;

property Handle: THandle read FHandle;

property Priority: TThreadPriority read GetPriority write SetPriority;

property Suspended: Boolean read FSuspended write SetSuspended;

property ThreadID: THandle read FThreadID;

property OnTerminate: TNotifyEvent read FOnTerminate write FOnTerminate;

end;

TThread类在Delphi的RTL里算是比较简单的类,类成员也不多,类属性都很简单明白,本文将只对几个比较重要的类成员方法和唯一的事件:OnTerminate作详细分析.

首先就是构造函数:

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;

虽然这个构造函数没有多少代码,但却可以算是最重要的一个成员,因为线程就是在这里被创建的.

在通过Inherited调用TObject.Create后,第一句就是调用一个过程:AddThread,其源码如下:

procedure AddThread;

begin

InterlockedIncrement(ThreadCount);

end;

同样有一个对应的RemoveThread:

procedure RemoveThread;

begin

InterlockedDecrement(ThreadCount);

end;

它们的功能很简单,就是通过增减一个全局变量来统计进程中的线程数.只是这里用于增减变量的并不是常用的Inc/Dec过程,而是用了InterlockedIncrement/InterlockedDecrement这一对过程,它们实现的功能完全一样,都是对变量加一或减一.但它们有一个最大的区别,那就是interlockedIncrement/InterlockedDecrement是线程安全的.即它们在多线程下能保证执行结果正确,而Inc/Dec不能.或者按操作系统理论中的术语来说,这是一对"原语"操作. 以加一为例来说明二者实现细节上的不同:

一般来说,对内存数据加一的操作分解以后有三个步骤:

1、 从内存中读出数据

2、 数据加一

3、 存入内存

现在假设在一个两个线程的应用中用Inc进行加一操作可能出现的一种情况:

1、 线程A从内存中读出数据(假设为3)

2、 线程B从内存中读出数据(也是3)

3、 线程A对数据加一(现在是4)

4、 线程B对数据加一(现在也是4)

5、 线程A将数据存入内存(现在内存中的数据是4)

6、 线程B也将数据存入内存(现在内存中的数据还是4,但两个线程都对它加了一,应该是5才对,所以这里出现了错误的结果)

而用InterlockIncrement过程则没有这个问题,因为所谓"原语"是一种不可中断的操作,即操作系统能保证在一个"原语"执行完毕前不会进行线程切换.所以在上面那个例子中,只有当线程A执行完将数据存入内存后,线程B才可以开始从中取数并进行加一操作,这样就保证了即使是在多线程情况下,结果也一定会是正确的.前面那个例子也说明一种"线程访问冲突"的情况,这也就是为什么线程之间需要"同步"Synchronize),关于这个,在后面说到同步时还会再详细讨论.

说到同步,有一个题外话:加拿大滑铁卢大学的教授李明曾就Synchronize一词在"线程同步"中被译作"同步"提出过异议,个人认为他说的其实很有道理.在中文中"同步"的意思是"同时发生",而"线程同步"目的就是避免这种"同时发生"的事情.而在英文中,Synchronize的意思有两个:一个是传统意义上的同步(To occur at the same time),另一个是"协调一致"(To operate in unison).在"线程同步"中的Synchronize一词应该是指后面一种意思,即"保证多个线程在访问同一数据时,保持协调一致,避免出错".不过像这样译得不准的词在IT业还有很多,既然已经是约定俗成了,本文也将继续沿用,只是在这里说明一下,因为软件开发是一项细致的工作,该弄清楚的,绝不能含糊.

本文来源：https://www.bwwdw.com/article/9qw4.html