CreateThread()与beginthread()的区别详细解析
转载 &更新时间：日 09:11:39 & 作者：
很多开发者不清楚这两者之间的关系，他们随意选一个函数来用，发现也没有什么大问题，于是就忙于解决更为紧迫的任务去了。等到有一天忽然发现一个程序运行时间很长的时候会有细微的内存泄露，开发者绝对不会想到是因为这两套函数用混的结果
我们知道在Windows下创建一个线程的方法有两种，一种就是调用Windows API CreateThread()来创建线程；另外一种就是调用MSVC CRT的函数_beginthread()或_beginthreadex()来创建线程。相应的退出线程也有两个函数Windows API的ExitThread()和CRT的_endthread()。这两套函数都是用来创建和退出线程的，它们有什么区别呢？
很多开发者不清楚这两者之间的关系，他们随意选一个函数来用，发现也没有什么大问题，于是就忙于解决更为紧迫的任务去了，而没有对它们进行深究。等到有一天忽然发现一个程序运行时间很长的时候会有细微的内存泄露，开发者绝对不会想到是因为这两套函数用混的结果。
根据Windows API和MSVC CRT的关系，可以看出来_beginthread()是对CreateThread()的包装，它最终还是调用CreateThread()来创建线程。那么在_beginthread()调用CreateThread()之前做了什么呢？我们可以看一下_beginthread()的源代码，它位于CRT源代码中的thread.c。我们可以发现它在调用CreateThread()之前申请了一个叫_tiddata的结构，然后将这个结构用_initptd()函数初始化之后传递给_beginthread()自己的线程入口函数_threadstart。_threadstart首先把由_beginthread()传过来的_tiddata结构指针保存到线程的显式TLS数组，然后它调用用户的线程入口真正开始线程。在用户线程结束之后，_threadstart()函数调用_endthread()结束线程。并且_threadstart还用__try/__except将用户线程入口函数包起来，用于捕获所有未处理的信号，并且将这些信号交给CRT处理。
所以除了信号之外，很明显CRT包装Windows API线程接口的最主要目的就是那个_tiddata。这个线程私有的结构里面保存的是什么呢？我们可以从mtdll.h中找到它的定义，它里面保存的是诸如线程ID、线程句柄、erron、strtok()的前一次调用位置、rand()函数的种子、异常处理等与CRT有关的而且是线程私有的信息。可见MSVC CRT并没有使用我们前面所说的__declspec(thread)这种方式来定义线程私有变量，从而防止库函数在多线程下失效，而是采用在堆上申请一个_tiddata结构，把线程私有变量放在结构内部，由显式TLS保存_tiddata的指针。
了解了这些信息以后，我们应该会想到一个问题，那就是如果我们用CreateThread()创建一个线程然后调用CRT的strtok()函数，按理说应该会出错，因为strtok()所需要的_tiddata并不存在，可是我们好像从来没碰到过这样的问题。查看strtok()函数就会发现，当一开始调用_getptd()去得到线程的_tiddata结构时，这个函数如果发现线程没有申请_tiddata结构，它就会申请这个结构并且负责初始化。于是无论我们调用哪个函数创建线程，都可以安全调用所有需要_tiddata的函数，因为一旦这个结构不存在，它就会被创建出来。
那么_tiddata在什么时候会被释放呢？ExitThread()肯定不会，因为它根本不知道有_tiddata这样一个结构存在，那么很明显是_endthread()释放的，这也正是CRT的做法。不过我们很多时候会发现，即使使用CreateThread()和ExitThread() （不调用ExitThread()直接退出线程函数的效果相同），也不会发现任何内存泄露，这又是为什么呢？经过仔细检查之后，我们发现原来密码在CRT DLL的入口函数DllMain中。我们知道，当一个进程/线程开始或退出的时候，每个DLL的DllMain都会被调用一次，于是动态链接版的CRT就有机会在DllMain中释放线程的_tiddata。可是DllMain只有当CRT是动态链接版的时候才起作用，静态链接CRT是没有DllMain的！这就是造成使用CreateThread()会导致内存泄露的一种情况，在这种情况下，_tiddata在线程结束时无法释放，造成了泄露。我们可以用下面这个小程序来测试： 代码如下:#include &Windows.h&#include &process.h&void thread(void *a){&&& char* r = strtok( "aaa", "b" );&&& ExitThread(0); // 这个函数是否调用都无所谓}int main(int argc, char* argv[]){&&& while(1) {&&&&&&& CreateThread(& 0, 0, (LPTHREAD_START_ROUTINE)thread, 0, 0, 0 );&&&&&&& Sleep( 5 );&&& }return 0;}如果用动态链接的CRT （/MD，/MDd）就不会有问题，但是，如果使用静态链接CRT （/MT，/MTd），运行程序后在进程管理器中观察它就会发现内存用量不停地上升，但是如果我们把thread()函数中的ExitThread()改成_endthread()就不会有问题，因为_endthread()会将_tiddata()释放。
这个问题可以总结为：当使用CRT时（基本上所有的程序都使用CRT），请尽量使用_beginthread()/_beginthreadex()/_endthread()/_endthreadex()这组函数来创建线程。在MFC中，还有一组类似的函数是AfxBeginThread()和AfxEndThread()，根据上面的原理类推，它是MFC层面的线程包装函数，它们会维护线程与MFC相关的结构，当我们使用MFC类库时，尽量使用它提供的线程包装函数以保证程序运行正确。
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具爱键-按键精灵多线程的使用及示例
一款软件或是一个脚本，其中多线程的运用是对脚本的效率和速度起到了绝对性的作用，所以学会多线程才能适
应于各种脚本的编写和运用。
多线程函数：BeginThread
使用示例：线程ID=BeginThread（线程）
BeginThread 同时运行过程
新开一个线程运行当前脚本，从指定的过程开始运行
字符串型，过程名
（注意：过程不能带参数，如：
Sub 过程(参数1)
使用时会造成未知问题。）
整数型，线程ID&&[注：按键精灵8.20版新增返回值参数]
下面由爱键提供按键精灵多线程的使用及示例：
/////////定义环境变量（多线程中的变量的传递，必须定义环境变量）//////////////
Dimenv xc1, xc2
主程序 = 0
////////主程序开始运行///////////////////////
ks1 = BeginThread(线程一)
ks2 = BeginThread(线程二)
主程序 = 主程序 + 1
TracePrint "主程序" & 主程序
///////////线程部分////////////////////////
Sub 线程一
&&& xc1 = xc1 +
&&& TracePrint
"线程一" & xc1
Sub 线程二
&&& xc2 = xc2 +
&&& TracePrint
"线程二" & xc2
以上代码可直接复制使用！
调试信息里可以看到：主程序、线程一、线程二&
它们是同时运行的。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。delphi 中几种多线程操作方式_西西软件资讯
西西软件园多重安全检测下载网站、值得信赖的软件下载站！
→ delphi 中几种多线程操作方式
在了解多线程之前我们先了解一下进程和线程的关系一个程序至少有一个主进程,一个进程至少有一个线程。为了保证线程的安全性请大家看看下面介绍 DELPHI多线程同步的一些处理方案大家可以参考:主线程又程为UI线程。进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。如果有兴趣深入的话，我建议你们看看《现代操作系统》或者《操作系统的设计与实现》。对就个问题说得比较清楚。多线程应该是编程工作者的基础技能, 但这个基础我从来没学过，所以仅仅是看上去会一些，明白了2+2的时候，其实我还不知道1+1。开始本应该是一篇洋洋洒洒的文字, 不过我还是提倡先做起来, 在尝试中去理解.先试试这个:procedure&TForm1.Button1Click(Sender:&TObject);&
&&for&i&:=&0&to&500000&do&
&&&&Canvas.TextOut(10,&10,&IntToStr(i));&
上面程序运行时, 我们的窗体基本是 &死& 的, 可以在你在程序运行期间拖动窗体试试...Delphi 为我们提供了一个简单的办法(Application.ProcessMessages)来解决这个问题:procedure&TForm1.Button1Click(Sender:&TObject);&
&&for&i&:=&0&to&500000&do&
&&&&Canvas.TextOut(10,&10,&IntToStr(i));&
&&&&Application.ProcessM&
这个 Application.ProcessM 一般用在比较费时的循环中, 它会检查并先处理消息队列中的其他消息.但这算不上多线程, 譬如: 运行中你拖动窗体, 循环会暂停下来...在使用多线程以前, 让我们先简单修改一下程序:function&MyFun:&I&
&&for&i&:=&0&to&500000&do&
&&&&Form1.Canvas.L&
&&&&Form1.Canvas.TextOut(10,&10,&IntToStr(i));&
&&&&Form1.Canvas.U&
&&Result&:=&0;&
procedure&TForm1.Button1Click(Sender:&TObject);&
细数上面程序的变化:1、首先这还不是多线程的, 也会让窗体假 &死& 一会;2、把执行代码写在了一个函数里, 但这个函数不属于 TForm1 的方法, 所以使用 Canvas 是必须冠以名称(Form1);3、既然是个函数, (不管是否必要)都应该有返回值;4、使用了 500001 次 Lock 和 Unlock.Canvas.Lock 好比在说: Canvas(绘图表面)正忙着呢, 其他想用 Canvas 的等会;Canvas.Unlock : 用完了, 解锁!在 Canvas 中使用 Lock 和 Unlock 是个好习惯, 在不使用多线程的情况下这无所谓, 但保不准哪天程序会扩展为多线程的; 我们现在学习多线程, 当然应该用.在 Delphi 中使用多线程有两种方法: 调用 API、使用 TThread 类; 使用 API 的代码更简单.function&MyFun(p:&Pointer):&I&&
&&for&i&:=&0&to&500000&do&
&&&&Form1.Canvas.L&
&&&&Form1.Canvas.TextOut(10,&10,&IntToStr(i));&
&&&&Form1.Canvas.U&
&&Result&:=&0;&
procedure&TForm1.Button1Click(Sender:&TObject);&
&&CreateThread(nil,&0,&@MyFun,&nil,&0,&ID);&
代码分析:CreateThread 一个线程后, 算上原来的主线程, 这样程序就有两个线程、是标准的多线程了;CreateThread 第三个参数是函数指针, 新线程建立后将立即执行该函数, 函数执行完毕, 系统将销毁此线程从而结束多线程的故事.CreateThread 要使用的函数是系统级别的, 不能是某个类(譬如: TForm1)的方法, 并且有严格的格式(参数、返回值)要求, 不管你暂时是不是需要都必须按格式来;因为是系统级调用, 还要缀上 stdcall, stdcall 是协调参数顺序的, 虽然这里只有一个参数没有顺序可言, 但这是使用系统函数的惯例.CreateThread 还需要一个 var 参数来接受新建线程的 ID, 尽管暂时没用, 但这也是格式; 其他参数以后再说吧.这样一个最简单的多线程程序就出来了, 咱们再用 TThread 类实现一次type&
&&TMyThread&=&class(TThread)&
&&protected&
&&&&procedure&E&&
procedure&TMyThread.E&
&&FreeOnTerminate&:=&T&{这可以让线程执行完毕后随即释放}&
&&for&i&:=&0&to&500000&do&
&&&&Form1.Canvas.L&
&&&&Form1.Canvas.TextOut(10,&10,&IntToStr(i));&
&&&&Form1.Canvas.U&
procedure&TForm1.Button1Click(Sender:&TObject);&
&&TMyThread.Create(False);&
TThread 类有一个抽象方法(Execute), 因而是个抽象类, 抽象类只能继承使用, 上面是继承为 TMyThread.继承 TThread 主要就是实现抽象方法 Execute(把我们的代码写在里面), 等我们的 TMyThread 实例化后, 首先就会执行 Execute 方法中的代码.按常规我们一般这样去实例化:procedure&TForm1.Button1Click(Sender:&TObject);&
&&MyThread:&TMyT&
&&MyThread&:=&TMyThread.Create(False);&
因为 MyThread 变量在这里毫无用处(并且编译器还有提示), 所以不如直接写做 TMyThread.Create(False);我们还可以轻松解决一个问题, 如果: TMyThread.Create(True) ?这样线程建立后就不会立即调用 Execute, 可以在需要的时候再用 Resume 方法执行线程, 譬如:procedure&TForm1.Button1Click(Sender:&TObject);&
&&MyThread:&TMyT&
&&MyThread&:=&TMyThread.Create(True);&
&&MyThread.R&
//可简化为:&
procedure&TForm1.Button1Click(Sender:&TObject);&
&&with&TMyThread.Create(True)&do&R&
一、入门㈠、function&CreateThread(&
&&lpThreadAttributes:&P&&&&&&&&&&&{安全设置}&
&&dwStackSize:&DWORD;&&&&&&&&&&&&&&&&&&&&{堆栈大小}&
&&lpStartAddress:&TFNThreadStartR&{入口函数}&
&&lpParameter:&P&&&&&&&&&&&&&&&&&&{函数参数}&
&&dwCreationFlags:&DWORD;&&&&&&&&&&&&&&&&{启动选项}&
&&var&lpThreadId:&DWORD&&&&&&&&&&&&&&&&&&{输出线程&ID&}&
):&TH&&&&&&&&&&&&&&&&&&&&&&{返回线程句柄}&
在 Windows 上建立一个线程, 离不开 CreateThread 函数;TThread.Create 就是先调用了 BeginThread (Delphi 自定义的), BeginThread 又调用的 CreateThread.既然有建立, 就该有释放, CreateThread 对应的释放函数是: ExitThread, 譬如下面代码:procedure&TForm1.Button1Click(Sender:&TObject);&
&&ExitThread(0);&{此句即可退出当前程序,&但不建议这样使用}&
代码注释:当前程序是一个进程, 进程只是一个工作环境, 线程是工作者;每个进程都会有一个启动线程(或叫主线程), 也就是说: 我们之前大量的编码都是写给这个主线程的;上面的 ExitThread(0); 就是退出这个主线程;系统不允许一个没有线程的进程存在, 所以程序就退出了.另外: ExitThread 函数的参数是一个退出码, 这个退出码是给之后的其他函数用的, 这里随便给个无符号整数即可.或许你会说: 这个 ExitThread 挺好用的; 其实不管是用 API 还是用 TThread 类写多线程, 我们很少用到它; 因为:1、假如直接使用 API 的 CreateThread, 它执行完入口函数后会自动退出, 无需 ExitT2、用 TThread 类建立的线程又绝不能使用 ExitThread 退出; 因为使用 TThread 建立线程时会同时分配更多资源(譬如你自定义的成员、还有它的祖先类(TObject)分配的资源等等), 如果用 ExitThread 给草草退出了, 这些资源将得不到释放而导致内存泄露. 尽管 Delphi 提供了 EndThread(其内部调用 ExitThread), 这也不需要我们手动操作(假如非要手动操作也是件很麻烦的事情, 因为很多时候你不知道线程是什么时候执行完毕的).除了 CreateThread, 还有一个 CreateRemoteThread, 可在其他进程中建立线程, 这不应该是现在学习的重点;现在先集中精力把 CreateThread 的参数搞彻底.倒着来吧, 先谈谈 CreateThread 将要返回的 &线程句柄&.&句柄& 类似指针, 但通过指针可读写对象, 通过句柄只是使用对象;有句柄的对象一般都是系统级别的对象(或叫内核对象); 之所以给我们的是句柄而不是指针, 目的只有一个: &安全&;貌似通过句柄能做很多事情, 但一般把句柄提交到某个函数(一般是系统函数)后, 我们也就到此为止很难了解更多了; 事实上是系统并不相信我们.不管是指针还是句柄, 都不过是内存中的一小块数据(一般用结构描述), 微软并没有公开句柄的结构细节, 猜一下它应该包括: 真实的指针地址、访问权限设置、引用计数等等.既然 CreateThread 可以返回一个句柄, 说明线程属于 &内核对象&.实际上不管线程属于哪个进程, 它们在系统的怀抱中是平等的; 在优先级(后面详谈)相同的情况下, 系统会在相同的时间间隔内来运行一下每个线程, 不过这个间隔很小很小, 以至于让我们误以为程序是在不间断地运行.这时你应该有一个疑问: 系统在去执行其他线程的时候, 是怎么记住前一个线程的数据状态的?有这样一个结构 TContext, 它基本上是一个 CPU 寄存器的集合, 线程是数据就是通过这个结构切换的, 我们也可以通过 GetThreadContext 函数读取寄存器看看.附上这个结构 TContext(或叫: CONTEXT、_CONTEXT) 的定义:PContext&=&^TC&
_CONTEXT&=&record&
&&ContextFlags:&DWORD;&
&&Dr0:&DWORD;&
&&Dr1:&DWORD;&
&&Dr2:&DWORD;&
&&Dr3:&DWORD;&
&&Dr6:&DWORD;&
&&Dr7:&DWORD;&
&&FloatSave:&TFloatingSaveA&
&&SegGs:&DWORD;&
&&SegFs:&DWORD;&
&&SegEs:&DWORD;&
&&SegDs:&DWORD;&
&&Edi:&DWORD;&
&&Esi:&DWORD;&
&&Ebx:&DWORD;&
&&Edx:&DWORD;&
&&Ecx:&DWORD;&
&&Eax:&DWORD;&
&&Ebp:&DWORD;&
&&Eip:&DWORD;&
&&SegCs:&DWORD;&
&&EFlags:&DWORD;&
&&Esp:&DWORD;&
&&SegSs:&DWORD;&
CreateThread 的最后一个参数是 &线程的 ID&;既然可以返回句柄, 为什么还要输出这个 ID? 现在我知道的是:1、线程的 ID 是唯一的; 而句柄可能不只一个, 譬如可以用 GetCurrentThread 获取一个伪句柄、可以用 DuplicateHandle 复制一个句柄等等.2、ID 比句柄更轻便.在主线程中 GetCurrentThreadId、MainThreadID、MainInstance 获取的都是主线程的 ID.㈡、启动选项function&CreateThread(&
&&lpThreadAttributes:&P&
&&dwStackSize:&DWORD;&
&&lpStartAddress:&TFNThreadStartR&
&&lpParameter:&P&
&&dwCreationFlags:&DWORD;&{启动选项}&
&&var&lpThreadId:&DWORD&
):&TH&CreateThread 的倒数第二个参数 dwCreationFlags(启动选项) 有两个可选值:0: 线程建立后立即执行入口函数;CREATE_SUSPENDED: 线程建立后会挂起等待.可用 ResumeThread 函数是恢复线程的运行; 可用 SuspendThread 再次挂起线程.这两个函数的参数都是线程句柄, 返回值是执行前的挂起计数.什么是挂起计数?SuspendThread 会给这个数 +1; ResumeThread 会给这个数 -1; 但这个数最小是 0.当这个数 = 0 时, 线程会运行; & 0 时会挂起.如果被 SuspendThread 多次, 同样需要 ResumeThread 多次才能恢复线程的运行.在下面的例子中, 有新线程不断给一个全局变量赋随机值;同时窗体上的 Timer 控件每隔 1/10 秒就把这个变量写在窗体标题;在这个过程中演示了 ResumeThread、SuspendThread 两个函数.//上面图片中演示的代码。&
unit&Unit1;&
interface&
&&Windows,&Messages,&SysUtils,&Variants,&Classes,&Graphics,&Controls,&Forms,&
&&Dialogs,&StdCtrls,&ExtC&
&&TForm1&=&class(TForm)&
&&&&Button1:&TB&
&&&&Button2:&TB&
&&&&Button3:&TB&
&&&&Timer1:&TT&
&&&&procedure&Button1Click(Sender:&TObject);&
&&&&procedure&Button2Click(Sender:&TObject);&
&&&&procedure&Button3Click(Sender:&TObject);&
&&&&procedure&FormCreate(Sender:&TObject);&
&&&&procedure&Timer1Timer(Sender:&TObject);&
&&Form1:&TForm1;&
implementation&
{$R&*.dfm}&
&&hThread:&TH&{线程句柄}&
&&num:&I&&&&&{全局变量,&用于记录随机数}&
{线程入口函数}&
function&MyThreadFun(p:&Pointer):&I&&
&&while&True&do&{假如线程不挂起,&这个循环将一直循环下去}&
&&&&num&:=&Random(100);&
&&Result&:=&0;&
{建立并挂起线程}&
procedure&TForm1.Button1Click(Sender:&TObject);&
&&ID:&DWORD;&
&&hThread&:=&CreateThread(nil,&0,&@MyThreadFun,&nil,&CREATE_SUSPENDED,&ID);&
&&Button1.Enabled&:=&F&
{唤醒并继续线程}&
procedure&TForm1.Button2Click(Sender:&TObject);&
&&ResumeThread(hThread);&
{挂起线程}&
procedure&TForm1.Button3Click(Sender:&TObject);&
&&SuspendThread(hThread);&
procedure&TForm1.FormCreate(Sender:&TObject);&
&&Timer1.Interval&:=&100;&
procedure&TForm1.Timer1Timer(Sender:&TObject);&
&&Text&:=&IntToStr(num);&
end.㈢、入口函数的参数function&CreateThread(&
&&lpThreadAttributes:&P&
&&dwStackSize:&DWORD;&
&&lpStartAddress:&TFNThreadStartR&
&&lpParameter:&P&&{入口函数的参数}&
&&dwCreationFlags:&DWORD;&
&&var&lpThreadId:&DWORD&
):&TH&线程入口函数的参数是个无类型指针(Pointer), 用它可以指定任何数据; 本例是把鼠标点击窗体的坐标传递给线程的入口函数, 每次点击窗体都会创建一个线程.运行效果图://上面演示的代码&
unit&Unit1;&
interface&
&&Windows,&Messages,&SysUtils,&Variants,&Classes,&Graphics,&Controls,&Forms,&
&&TForm1&=&class(TForm)&
&&&&procedure&FormMouseUp(Sender:&TO&Button:&TMouseB&
&&&&&&Shift:&TShiftS&X,&Y:&Integer);&
&&Form1:&TForm1;&
implementation&
{$R&*.dfm}&
&&pt:&TP&{这个坐标点将会已指针的方式传递给线程,&它应该是全局的}&
function&MyThreadFun(p:&Pointer):&I&&
&&pt2:&TP&&&&&&&{因为指针参数给的点随时都在变,&需用线程的局部变量存起来}&
&&pt2&:=&PPoint(p)^;&{转换}&
&&for&i&:=&0&to&1000000&do&
&&&&with&Form1.Canvas&do&begin&
&&&&&&TextOut(pt2.X,&pt2.Y,&IntToStr(i));&
&&Result&:=&0;&
procedure&TForm1.FormMouseUp(Sender:&TO&Button:&TMouseB&
&&Shift:&TShiftS&X,&Y:&Integer);&
&&ID:&DWORD;&
&&pt&:=&Point(X,&Y);&
&&CreateThread(nil,&0,&@MyThreadFun,&@pt,&0,&ID);&
&&{下面这种写法更好理解,&其实不必,&因为&PPoint&会自动转换为&Pointer&的}&
&&//CreateThread(nil,&0,&@MyThreadFun,&Pointer(@pt),&0,&ID);&
end.这个例子还有不严谨的地方: 当一个线程 Lock 窗体的 Canvas 时, 其他线程在等待; 线程在等待时, 其中的计数也还在增加. 这也就是说: 现在并没有去处理线程的同步; 同步是多线程中最重要的课题, 快到了.另外有个小技巧: 线程函数的参数是个 32 位(4个字节)的指针, 仅就本例来讲, 可以让它的 &高16位& 和 &低16位& 分别携带 X 和 Y; 这样就不需要哪个全局的 pt 变量了.其实在 Windows 的消息中就是这样传递坐标的, 在 Windows 的消息中一般高字节是 Y、低字节是 X; 咱们这么来吧, 这样还可以使用给消息准备的一些方便的函数.重写本例代码(当然运行效果和窗体文件都是一样的):unit&Unit1;&
interface&
&&Windows,&Messages,&SysUtils,&Variants,&Classes,&Graphics,&Controls,&Forms,&
&&TForm1&=&class(TForm)&
&&&&procedure&FormMouseUp(Sender:&TO&Button:&TMouseB&
&&&&&&Shift:&TShiftS&X,&Y:&Integer);&
&&Form1:&TForm1;&
implementation&
{$R&*.dfm}&
function&MyThreadFun(p:&Pointer):&I&&
&&x&:=&LoWord(Integer(p));&
&&y&:=&HiWord(Integer(p));&
&&{如果不使用&LoWord、HiWord&函数可以像下面这样:&}&
&&//x&:=&Integer(p);&
&&//y&:=&Integer(p)&shr&16;&
&&for&i&:=&0&to&1000000&do&
&&&&with&Form1.Canvas&do&begin&
&&&&&&TextOut(x,&y,&IntToStr(i));&
&&Result&:=&0;&
procedure&TForm1.FormMouseUp(Sender:&TO&Button:&TMouseB&
&&Shift:&TShiftS&X,&Y:&Integer);&
&&ID:&DWORD;&
&&num&:=&MakeLong(X,&Y);&
&&{如果不使用&MekeLong、MakeWParam、MakeLParam、MakeResult&等函数,&可以像下面这样:&}&
&&//num&:=&Y&shl&16&+&X;&
&&CreateThread(nil,&0,&@MyThreadFun,&Ptr(num),&0,&ID);&
&&{上面的&Ptr&是专门将一个数字转换为指针的函数,&当然也可以这样:&}&
&&//CreateThread(nil,&0,&@MyThreadFun,&Pointer(num),&0,&ID);&
end.㈣、入口函数的指针function&CreateThread(&
&&lpThreadAttributes:&P&
&&dwStackSize:&DWORD;&
&&lpStartAddress:&TFNThreadStartR&{入口函数的指针}&
&&lpParameter:&P&&
&&dwCreationFlags:&DWORD;&
&&var&lpThreadId:&DWORD&
):&TH&到了入口函数了, 学到这个地方, 我查了一个入口函数的标准定义, 这个函数的标准返回值应该是 DWORD, 不过这函数在 Delphi 的 System 单元定义的是: TThreadFunc = function(Parameter: Pointer): I 我以后会尽量使用 DWORD 做入口函数的返回值.这个返回值有什么用呢?等线程退出后, 我们用 GetExitCodeThread 函数获取的退出码就是这个返回值!如果线程没有退出, GetExitCodeThread 获取的退出码将是一个常量 STILL_ACTIVE (259); 这样我们就可以通过退出码来判断线程是否已退出.还有一个问题: 前面也提到过, 线程函数不能是某个类的方法! 假如我们非要线程去执行类中的一个方法能否实现呢?尽管可以用 Addr(类名.方法名) 或 MethodAddress('published 区的方法名') 获取类中方法的地址, 但都不能当做线程的入口函数, 原因可能是因为类中的方法的地址是在实例化为对象时动态分配的.后来换了个思路, 其实很简单: 在线程函数中再调用方法不就得了, 估计 TThread 也应该是这样.下面的例子就尝试了用线程调用 TForm1 类中的方法, 并测试了退出码的相关问题.unit&Unit1;&
interface&
&&Windows,&Messages,&SysUtils,&Variants,&Classes,&Graphics,&Controls,&Forms,&
&&Dialogs,&StdC&
&&TForm1&=&class(TForm)&
&&&&Button1:&TB&
&&&&Button2:&TB&
&&&&procedure&Button1Click(Sender:&TObject);&
&&&&procedure&Button2Click(Sender:&TObject);&
&&&&private&
&&&&&&procedure&FormP&{准备给线程使用的方法}&
&&Form1:&TForm1;&
implementation&
{$R&*.dfm}&
&&hThread:&TH&
{线程入口函数}&
function&MyThreadFun(p:&Pointer):&DWORD;&&
&&Form1.FormP&{调用&TForm1&类的方法}&
&&Result&:=&99;&&&{这个返回值将成为线程的退出代码,&99&是我随意给的数字}&
{TForm1&的方法,&本例中是给线程的入口函数调用的}&
procedure&TForm1.FormP&
&&for&i&:=&0&to&200000&do&
&&&&with&Form1.Canvas&do&begin&
&&&&&&TextOut(10,&10,&IntToStr(i));&
{建立并执行线程}&
procedure&TForm1.Button1Click(Sender:&TObject);&
&&ID:&DWORD;&
&&hThread&:=&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ID);&
{获取线程的退出代码,&并判断线程是否退出}&
procedure&TForm1.Button2Click(Sender:&TObject);&
&&ExitCode:&DWORD;&
&&GetExitCodeThread(hThread,&ExitCode);&
&&if&hThread&=&0&then&
&&&&Text&:=&'线程还未启动';&
&&if&ExitCode&=&STILL_ACTIVE&then&
&&&&Text&:=&Format('线程退出代码是:&%d,&表示线程还未退出',&[ExitCode])&
&&&&Text&:=&Format('线程已退出,&退出代码是:&%d',&[ExitCode]);&
end.㈤、堆栈大小function&CreateThread(&
&&lpThreadAttributes:&P&
&&dwStackSize:&DWORD;&&{堆栈大小}&
&&lpStartAddress:&TFNThreadStartR&&
&&lpParameter:&P&&
&&dwCreationFlags:&DWORD;&
&&var&lpThreadId:&DWORD&
):&TH&CreateThread 的第二个参数是分配给线程的堆栈大小.这首先这可以让我们知道: 每个线程都有自己独立的堆栈(也拥有自己的消息队列).什么是堆栈? 其实堆是堆、栈是栈, 有时 &栈& 也被叫做 &堆栈&.它们都是进程中的内存区域, 主要是存取方式不同(栈:先进后出; 堆:先进先出);&栈&(或叫堆栈)适合存取临时而轻便的变量, 主要用来储存局部变量; 譬如 for i := 0 to 99 do 中的 i 就只能存于栈中, 你把一个全局的变量用于 for 循环计数是不可以的.现在我们知道了线程有自己的 &栈&, 并且在建立线程时可以分配栈的大小.前面所有的例子中, 这个值都是 0, 这表示使用系统默认的大小, 默认和主线程栈的大小一样, 如果不够用会自动增长;那主线程的栈有多大? 这个值是可以设定的: Project -& Options -& linker -& memory size(如图)栈是私有的但堆是公用的, 如果不同的线程都来使用一个全局变量有点乱套;为解决这个问题 Delphi 为我们提供了一个类似 var 的 ThreadVar 关键字, 线程在使用 ThreadVar 声明的全局变量时会在各自的栈中留一个副本, 这样就解决了冲突. 不过还是尽量使用局部变量, 或者在继承 TThread 时使用类的成员变量, 因为 ThreadVar 的效率不好, 据说比局部变量能慢 10 倍.在下面的例子就测试了用 var 和 ThreadVar 定义变量的不同.使用 var 效果图:使用 ThreadVar 效果图:unit&Unit1;&
interface&
&&Windows,&Messages,&SysUtils,&Variants,&Classes,&Graphics,&Controls,&Forms,&
&&Dialogs,&StdC&
&&TForm1&=&class(TForm)&
&&&&Button1:&TB&
&&&&procedure&Button1Click(Sender:&TObject);&
&&Form1:&TForm1;&
implementation&
{$R&*.dfm}&
//var&num:&I&&&&&{全局变量}&
threadvar&num:&I&{支持多线程的全局变量}&
function&MyThreadFun(p:&Pointer):&DWORD;&&
&&py&:=&Integer(p);&
&&while&True&do&
&&&&Inc(num);&
&&&&with&Form1.Canvas&do&begin&
&&&&&&TextOut(20,&py,&IntToStr(num));&
&&&&Sleep(1000);&{然线程挂起&1&秒钟再继续}&
procedure&TForm1.Button1Click(Sender:&TObject);&
&&ID:&DWORD;&
&&{借入口函数的参数传递了一个坐标点中的&Y&值,&以让各线程把结果输出在不同位置}&
&&CreateThread(nil,&0,&@MyThreadFun,&Ptr(20),&0,&ID);&
&&CreateThread(nil,&0,&@MyThreadFun,&Ptr(40),&0,&ID);&
&&CreateThread(nil,&0,&@MyThreadFun,&Ptr(60),&0,&ID);&
end.㈥、安全设置function&CreateThread(&
&&lpThreadAttributes:&P&{安全设置}&
&&dwStackSize:&DWORD;&
&&lpStartAddress:&TFNThreadStartR&&
&&lpParameter:&P&&
&&dwCreationFlags:&DWORD;&
&&var&lpThreadId:&DWORD&
):&TH&CreateThread 的第一个参数 lpThreadAttributes 是指向 TSecurityAttributes 结构的指针, 一般都是置为 nil, 这表示没有访问限制; 该结构的定义是://TSecurityAttributes(又名:&SECURITY_ATTRIBUTES、_SECURITY_ATTRIBUTES)&
_SECURITY_ATTRIBUTES&=&record&
&&nLength:&DWORD;&&&&&&&&&&&&&&&&{结构大小}&
&&lpSecurityDescriptor:&P&{默认&&这是另一个结构&TSecurityDescriptor&的指针}&
&&bInheritHandle:&BOOL;&&&&&&&&&&{默认&False,&表示不可继承}&
//TSecurityDescriptor(又名:&SECURITY_DESCRIPTOR、_SECURITY_DESCRIPTOR)&
_SECURITY_DESCRIPTOR&=&record&
&&Revision:&B&
&&Sbz1:&B&
&&Control:&SECURITY_DESCRIPTOR_CONTROL;&
&&Owner:&PSID;&
&&Group:&PSID;&
&&Sacl:&PACL;&
&&Dacl:&PACL;&
end;够复杂的, 但我们在多线程编程时不需要去设置它们, 大都是使用默认设置(也就是赋值为 nil).我觉得有必要在此刻了解的是: 建立系统内核对象时一般都有这个属性(TSecurityAttributes);在接下来多线程的课题中要使用一些内核对象, 不如先盘点一下, 到时碰到这个属性时给个 nil 即可, 不必再费神.{建立事件}&
function&CreateEvent(&
&&lpEventAttributes:&PSecurityA&{!}&
&&bManualReset:&BOOL;&
&&bInitialState:&BOOL;&
&&lpName:&PWideChar&
{建立互斥}&
function&CreateMutex(&
&&lpMutexAttributes:&PSecurityA&{!}&
&&bInitialOwner:&BOOL;&
&&lpName:&PWideChar&
{建立信号}&
function&CreateSemaphore(&
&&lpSemaphoreAttributes:&PSecurityA&{!}&
&&lInitialCount:&L&
&&lMaximumCount:&L&
&&lpName:&PWideChar&
{建立等待}&
function&CreateWaitableTimer(&
&&lpTimerAttributes:&PSecurityA&{!}&
&&bManualReset:&BOOL;&
&&lpTimerName:&PWideChar&
上面的四个系统内核对象(事件、互斥、信号、计时器)都是线程同步的手段, 从这也能看出处理线程同步的复杂性; 不过这还不是全部, Windows Vista 开始又增加了 Condition variables(条件变量)、Slim Reader-Writer Locks(读写锁)等同步手段.不过最简单、最轻便(速度最快)的同步手段还是 CriticalSection(临界区), 但它不属于系统内核对象, 当然也就没有句柄、没有 TSecurityAttributes 这个安全属性, 这也导致它不能跨进程使用; 不过写多线程时一般不用跨进程, 所以 CriticalSection 应该是最常用的同步手段.二、临界区。先看一段程序, 代码文件:unit&Unit1;&
interface&
&&Windows,&Messages,&SysUtils,&Variants,&Classes,&Graphics,&Controls,&Forms,&
&&Dialogs,&StdC&
&&TForm1&=&class(TForm)&
&&&&ListBox1:&TListB&
&&&&Button1:&TB&
&&&&procedure&FormCreate(Sender:&TObject);&
&&&&procedure&Button1Click(Sender:&TObject);&
&&Form1:&TForm1;&
implementation&
{$R&*.dfm}&
function&MyThreadFun(p:&Pointer):&DWORD;&&
&&for&i&:=&0&to&99&do&Form1.ListBox1.Items.Add(IntToStr(i));&
&&Result&:=&0;&
procedure&TForm1.Button1Click(Sender:&TObject);&
&&ID:&DWORD;&
&&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ID);&
&&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ID);&
&&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ID);&
procedure&TForm1.FormCreate(Sender:&TObject);&
&&ListBox1.Align&:=&alL&
end.在这段程序中, 有三个线程几乎是同时建立, 向窗体中的 ListBox1 中写数据, 最后写出的结果是这样的:能不能让它们别打架, 一个完了另一个再来? 这就要用到多线程的同步技术.前面说过, 最简单的同步手段就是 &临界区&.先说这个 &同步&(Synchronize), 首先这个名字起的不好, 我们好像需要的是 &异步&; 其实异步也不准确...管它叫什么名字呢, 它的目的就是保证不冲突、有次序、都发生.&临界区&(CriticalSection): 当把一段代码放入一个临界区, 线程执行到临界区时就独占了, 让其他也要执行此代码的线程先等等; 这和前面用的 Lock 和 UnLock 差不多; 使用格式如下:var&CS:&TRTLCriticalS&&&{声明一个&TRTLCriticalSection&结构类型变量;&它应该是全局的}&
InitializeCriticalSection(CS);&{初始化}&
EnterCriticalSection(CS);&&&&&&{开始:&轮到我了其他线程走开}&
LeaveCriticalSection(CS);&&&&&&{结束:&其他线程可以来了}&
DeleteCriticalSection(CS);&&&&&{删除:&注意不能过早删除}&
//也可用&TryEnterCriticalSection&替代&EnterCriticalSection.用上临界区, 重写上面的代码, 运行效果图://用临界区重写后的代码文件:&
unit&Unit1;&
interface&
&&Windows,&Messages,&SysUtils,&Variants,&Classes,&Graphics,&Controls,&Forms,&
&&Dialogs,&StdC&
&&TForm1&=&class(TForm)&
&&&&ListBox1:&TListB&
&&&&Button1:&TB&
&&&&procedure&FormCreate(Sender:&TObject);&
&&&&procedure&FormDestroy(Sender:&TObject);&
&&&&procedure&Button1Click(Sender:&TObject);&
&&Form1:&TForm1;&
implementation&
{$R&*.dfm}&
&&CS:&TRTLCriticalS&
function&MyThreadFun(p:&Pointer):&DWORD;&&
&&EnterCriticalSection(CS);&
&&for&i&:=&0&to&99&do&Form1.ListBox1.Items.Add(IntToStr(i));&
&&LeaveCriticalSection(CS);&
&&Result&:=&0;&
procedure&TForm1.Button1Click(Sender:&TObject);&
&&ID:&DWORD;&
&&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ID);&
&&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ID);&
&&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ID);&
procedure&TForm1.FormCreate(Sender:&TObject);&
&&ListBox1.Align&:=&alL&
&&InitializeCriticalSection(CS);&
procedure&TForm1.FormDestroy(Sender:&TObject);&
&&DeleteCriticalSection(CS);&
end.Delphi 在 SyncObjs 单元给封装了一个 TCriticalSection 类, 用法差不多, 代码如下:unit&Unit1;&
interface&
&&Windows,&Messages,&SysUtils,&Variants,&Classes,&Graphics,&Controls,&Forms,&
&&Dialogs,&StdC&
&&TForm1&=&class(TForm)&
&&&&ListBox1:&TListB&
&&&&Button1:&TB&
&&&&procedure&FormCreate(Sender:&TObject);&
&&&&procedure&FormDestroy(Sender:&TObject);&
&&&&procedure&Button1Click(Sender:&TObject);&
&&Form1:&TForm1;&
implementation&
{$R&*.dfm}&
uses&SyncO&
&&CS:&TCriticalS&
function&MyThreadFun(p:&Pointer):&DWORD;&&
&&for&i&:=&0&to&99&do&Form1.ListBox1.Items.Add(IntToStr(i));&
&&Result&:=&0;&
procedure&TForm1.Button1Click(Sender:&TObject);&
&&ID:&DWORD;&
&&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ID);&
&&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ID);&
&&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ID);&
procedure&TForm1.FormCreate(Sender:&TObject);&
&&ListBox1.Align&:=&alL&
&&CS&:=&TCriticalSection.C&
procedure&TForm1.FormDestroy(Sender:&TObject);&
end.三、等待函数 WaitForSingleObject一下子跳到等待函数 WaitForSingleObject, 是因为下面的 Mutex、Semaphore、Event、WaitableTimer 等同步手段都要使用这个函数; 不过等待函数可不止 WaitForSingleObject 它一个, 但它最简单.function&WaitForSingleObject(&
&&hHandle:&TH&&&&&&{要等待的对象句柄}&
&&dwMilliseconds:&DWORD&&{等待的时间,&单位是毫秒}&
):&DWORD;&&&&&&&&{返回值如下:}&
WAIT_OBJECT_0&&{等着了,&本例中是:&等的那个进程终于结束了}&
WAIT_TIMEOUT&&&{等过了点(你指定的时间),&也没等着}&
WAIT_ABANDONED&{好不容易等着了,&但人家还是不让咱执行;&这一般是互斥对象}&
//WaitForSingleObject&的第二个参数一般给常数值&INFINITE,&表示一直等下去,&死等.&
WaitForSingleObject 等待什么? 在多线程里就是等待另一个线程的结束, 快来执行自己的代码; 不过它可以等待的对象可不止线程; 这里先来一个等待另一个进程结束的例子, 运行效果图://WaitForSingleObject的示例代码文件:&
unit&Unit1;&
interface&
&&Windows,&Messages,&SysUtils,&Variants,&Classes,&Graphics,&Controls,&Forms,&
&&Dialogs,&StdC&
&&TForm1&=&class(TForm)&
&&&&Button1:&TB&
&&&&procedure&Button1Click(Sender:&TObject);&
&&Form1:&TForm1;&
implementation&
{$R&*.dfm}&
&&hProcess:&TH&{进程句柄}&
{等待一个指定句柄的进程什么时候结束}&
function&MyThreadFun(p:&Pointer):&DWORD;&&
&&if&WaitForSingleObject(hProcess,&INFINITE)&=&WAIT_OBJECT_0&then&
&&&&Form1.Text&:=&Format('进程&%d&已关闭',&[hProcess]);&
&&Result&:=&0;&
{启动一个进程,&并建立新线程等待它的结束}&
procedure&TForm1.Button1Click(Sender:&TObject);&
&&pInfo:&TProcessI&
&&sInfo:&TStartupI&
&&Path:&array[0..MAX_PATH-1]&of&C&
&&ThreadID:&DWORD;&
&&{先获取记事本的路径}&
&&GetSystemDirectory(Path,&MAX_PATH);&
&&StrCat(Path,&'\notepad.exe');&
&&{用&CreateProcess&打开记事本并获取其进程句柄,&然后建立线程监视}&
&&FillChar(sInfo,&SizeOf(sInfo),&0);&
&&if&CreateProcess(Path,&nil,&nil,&nil,&False,&0,&nil,&nil,&sInfo,&pInfo)&then&
&&&&hProcess&:=&pInfo.hP&&&&&&&&&&&&&&&&&&&&&&&&&&&{获取进程句柄}&
&&&&Text&:=&Format('进程&%d&已启动',&[hProcess]);&&
&&&&CreateThread(nil,&0,&@MyThreadFun,&nil,&0,&ThreadID);&{建立线程监视}&
07-2110-2808-2008-0308-0207-2507-2504-2403-2602-25
阅读本文后您有什么感想? 已有23人给出评价!
名称大小下载