[Delphi]多线程编程(9)认识等待函数 WaitForSingleObject

合集下载

(转)WaitForSingleObject函数用法

(转)WaitForSingleObject函数用法

(转)WaitForSingleObject函数⽤法等待函数可使线程⾃愿进⼊等待状态,直到⼀个特定的内核对象变为已通知状态为⽌。

这些等待函数中最常⽤的是WaitForSingleObject:DWORD WaitForSingleObject(HANDLE hObject, DWORD dwMilliseconds);当线程调⽤该函数时,第⼀个参数hObject标识⼀个能够⽀持被通知/未通知的内核对象。

第⼆个参数dwMilliseconds.允许该线程指明,为了等待该对象变为已通知状态,它将等待多长时间。

调⽤下⾯这个函数将告诉系统,调⽤函数准备等待到h P r o c e s s句柄标识的进程终⽌运⾏为⽌:WaitForSingleObject(hProcess, INFINITE);第⼆个参数告诉系统,调⽤线程愿意永远等待下去(⽆限时间量),直到该进程终⽌运⾏。

通常情况下, I N F I N I T E是作为第⼆个参数传递给Wa i t F o r S i n g l e O b j e c t的,不过也可以传递任何⼀个值(以毫秒计算)。

顺便说⼀下, I N F I N I T E已经定义为0 x F F F F F F F F(或-1)。

当然,传递I N F I N I T E有些危险。

如果对象永远不变为已通知状态,那么调⽤线程永远不会被唤醒,它将永远处于死锁状态,不过,它不会浪费宝贵的C P U时间。

下⾯是如何⽤⼀个超时值⽽不是I N F I N I T E来调⽤Wa i t F o r S i n g l e O b j e c t的例⼦:DWORD dw = WaitForSingleObject(hProcess, 5000);switch(dw){case WAIT_OBJECT_0:// The process terminated.break;case WAIT_TIMEOUT:// The process did not terminate within 5000 milliseconds.break;case WAIT_FAILED:// Bad call to function (invalid handle?)break;}上⾯这个代码告诉系统,在特定的进程终⽌运⾏之前,或者在5 0 0 0 m s时间结束之前,调⽤线程不应该变为可调度状态。

waitforsingleobject用法

waitforsingleobject用法

waitforsingleobject用法WaitForSingleObject是Windows API中的一个函数,用于等待一个对象的信号状态。

在多线程编程中,它是非常重要的一个函数,可以用来同步线程的执行顺序,避免竞争条件的发生。

WaitForSingleObject的用法非常简单,它只有两个参数:要等待的对象句柄和等待的时间。

对象句柄可以是一个线程句柄、进程句柄、事件句柄、互斥体句柄、信号量句柄等等。

等待的时间可以是一个固定的时间,也可以是一个无限等待。

当WaitForSingleObject函数被调用时,它会阻塞当前线程的执行,直到等待的对象被信号激活或者等待时间到达。

如果等待的对象已经被信号激活,那么函数会立即返回WAIT_OBJECT_0,表示等待成功。

如果等待的时间到达,但是等待的对象还没有被信号激活,那么函数会返回WAIT_TIMEOUT,表示等待超时。

如果等待的对象句柄无效,那么函数会返回WAIT_FAILED,表示等待失败。

下面是一个简单的例子,演示了如何使用WaitForSingleObject函数等待一个线程的结束:```c++#include <Windows.h>#include <iostream>DWORD WINAPI ThreadProc(LPVOID lpParam){std::cout << "Thread is running..." << std::endl;Sleep(5000);std::cout << "Thread is exiting..." << std::endl;return 0;}int main(){HANDLE hThread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);if (hThread == NULL){std::cerr << "Failed to create thread!" << std::endl;return 1;}DWORD dwResult = WaitForSingleObject(hThread, INFINITE); if (dwResult == WAIT_OBJECT_0){std::cout << "Thread is exited!" << std::endl;}else if (dwResult == WAIT_TIMEOUT){std::cerr << "Wait for thread timeout!" << std::endl;}else if (dwResult == WAIT_FAILED){std::cerr << "Wait for thread failed!" << std::endl;}CloseHandle(hThread);return 0;}```在这个例子中,我们创建了一个线程,并使用WaitForSingleObject 函数等待它的结束。

waitforsingleobject简书

waitforsingleobject简书

waitforsingleobject 简书WaitForSingleObject 是一个Windows API 函数,用于使一个线程等待一个对象的状态变为指定状态,直到超时或该对象被另一个线程设置。

这个函数通常用于同步操作,确保线程按照特定的顺序执行。

以下是WaitForSingleObject 的基本语法:c1DWORDWaitForSingleObject( 2HANDLEhHandle, 3DWORDdwMilliseconds 4);参数说明:DWORD WaitForSingleObject( 2HANDLE hHandle, 3DWORD dwMilliseconds 4);参数说明:2HANDLE hHandle, 3DWORD dwMilliseconds 4);参数说明: HANDLE hHandle, 3DWORD dwMilliseconds 4);参数说明:3DWORD dwMilliseconds 4);参数说明:DWORD dwMilliseconds 4);参数说明:4);参数说明:);参数说明: 参数说明:hHandle :一个句柄,标识要等待的对象。

这个对象可以是事件、互斥体、信号量或作业队列。

dwMilliseconds :等待的时间,以毫秒为单位。

如果设置为0,函数会立即返回。

如果设置为INFINITE ,函数将无限期地等待。

如果函数在指定的时间内达到了所期望的状态,则返回0。

如果函数因为超时而返回,则返回WAIT_TIMEOUT 。

使用WaitForSingleObject 时需要注意以下几点:1.死锁:如果一个线程在等待一个对象,而另一个线程拥有该对象并等待其他对象,那么两个线程都会被阻塞,导致死锁。

为了避免死锁,应确保对象的获取和释放遵循一定的顺序。

2.优先级反转:在多线程环境中,低优先级的线程可能会长时间占用资源,从而阻止高优先级的线程执行。

这可能导致性能问题或死锁。

WaitForSingleObject的用法

WaitForSingleObject的用法

WaitForSingleObject的用法1.WaitForSingleObject 的用法DWORDWaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);参数hHandle 是一个事件的句柄,第二个参数dwMilliseconds 是时间间隔。

如果时间是有信号状态返回WAIT_OBJECT_0 ,如果时间超过dwMilliseconds 值但时间事件还是无信号状态则返回W AIT_TIMEOUT 。

hHandle 可以是下列对象的句柄:Change notificationConsole inputEventJobMemory resource notificationMutexProcessSemaphoreThreadWaitable timerWaitForSingleObject 函数用来检测hHandle 事件的信号状态,当函数的执行时间超过dwMilliseconds 就返回,但如果参数dwMilliseconds 为INFINITE 时函数将直到相应时间事件变成有信号状态才返回,否则就一直等待下去,直到WaitForSingleObject 有返回直才执行后面的代码。

在这里举个例子:先创建一个全局Event 对象g_event:CEvent g_event;在程序中可以通过调用CEvent::SetEvent 设置事件为有信号状态。

下面是一个线程函数MyThreadPro()UINT CFlushDlg::MyThreadProc( LPVOID pParam ){WaitForSingleObject(g_event,INFINITE);For(;;){………… .}return 0;}在这个线程函数中只有设置g_event 为有信号状态时才执行下面的for 循环,因为g_event 是全局变量,所以我们可以在别的线程中通过g_event. SetEvent 控制这个线程。

waitforsingleobject 示例

waitforsingleobject 示例

waitforsingleobject 示例摘要:1.等待单个对象的WaitForSingleObject 函数概述2.WaitForSingleObject 函数的用法和参数3.使用WaitForSingleObject 函数的示例4.总结WaitForSingleObject 函数在编程中的应用正文:在Windows 操作系统中,WaitForSingleObject 函数是一个用于等待单个对象的函数。

它属于内核对象函数,可以在Windows SDK 或者C++ 语言中使用。

WaitForSingleObject 函数的作用是使线程阻塞,直到所指定的内核对象变为可用状态。

该函数在多线程编程中具有广泛的应用,例如等待某个条件变量、等待文件操作完成等。

WaitForSingleObject 函数的语法如下:```cppHANDLE hObject; // 要等待的内核对象句柄DWORD dwMilliseconds; // 等待的时间,以毫秒为单位DWORD WaitForSingleObject(HANDLE hObject, DWORD dwMilliseconds);```函数的参数有两个:- `hObject`:等待的内核对象句柄,例如一个互斥锁、信号量等。

- `dwMilliseconds`:等待的时间,以毫秒为单位。

如果等待时间为0,则函数立即返回;如果等待时间大于0,则函数将阻塞线程,直到超时或内核对象变为可用状态。

如果超时时间到达仍然没有返回,则函数将返回WAIT_TIMEOUT。

下面是一个使用WaitForSingleObject 函数的示例:```cpp#include <iostream>#include <Windows.h>using namespace std;int main(){HANDLE hMutex = CreateMutex(NULL, FALSE, "MyMutex");if (hMutex == NULL){cout << "创建互斥锁失败" << endl;return 1;}// 等待互斥锁DWORD dwRet = WaitForSingleObject(hMutex, 5000);if (dwRet == WAIT_OBJECT_0){cout << "成功获取互斥锁" << endl;}else if (dwRet == WAIT_TIMEOUT){cout << "等待超时" << endl;}else{cout << "其他错误" << endl;}// 释放互斥锁ReleaseMutex(hMutex);CloseHandle(hMutex);return 0;}```在这个示例中,我们首先创建了一个名为"MyMutex" 的互斥锁。

waitforsingleobject 详解

waitforsingleobject 详解

waitforsingleobject 详解WaitForSingleObject 是在 Windows 操作系统中使用的一个函数,它用来等待一个指定的对象进入有限状态。

这个函数的作用是让当前线程进入休眠状态,直到指定的对象变为有限状态。

WaitForSingleObject 函数的功能非常强大,它可以用于多种不同的对象,包括线程、进程、事件、互斥体和信号量等等。

它的使用能够控制线程或进程之间的同步和互斥行为。

函数的用法非常简单,它只有两个参数:对象的句柄和等待时间。

对象的句柄是用来标识一个特定的对象的,等待时间是一个超时值,用于设置函数的等待时间。

当指定的对象进入有限状态时,函数会返回 WAIT_OBJECT_0,表示成功;当超过等待时间时,函数会返回WAIT_TIMEOUT,表示超时;如果函数调用出现错误,则会返回一个错误代码。

WaitForSingleObject 是一种阻塞函数,它会阻塞当前线程,直到指定的对象进入有限状态。

在调用该函数时,线程会被挂起,直到满足等待条件。

这种阻塞方式能够帮助开发者实现多线程程序的同步控制,确保线程之间的协调执行。

此外,WaitForSingleObject 还支持对多个对象进行等待。

通过传递一个对象句柄数组和等待时间,我们可以同时等待多个对象进入有限状态。

这种功能对于处理复杂的同步和互斥场景非常有用。

总结一下,WaitForSingleObject 是 Windows 操作系统提供的一个重要函数,用于控制线程或进程之间的同步行为。

通过指定需要等待的对象和等待时间,我们可以实现对指定对象的等待,直到其进入有限状态。

这种函数的使用在多线程编程和进程间通信中非常常见,能够有效提升程序的性能和效率。

希望本文对你理解和使用 WaitForSingleObject 提供了帮助。

delphi waitformultipleobjects event

delphi waitformultipleobjects event

delphi waitformultipleobjects event在Delphi中,WaitForMultipleObjects函数是Windows API函数,用于使线程等待一组句柄中的任何一个变得可用。

当你要在Delphi中创建一个多线程应用程序,并需要等待多个事件或对象时,可以使用这个函数。

WaitForMultipleObjects函数的原型如下:pascalfunction WaitForMultipleObjects(Count: Longint;const Objects: array of PObject;WaitAll: Boolean;Timeout: Longint = -1): Longint; stdcall;其中,Objects参数是一个指向对象数组的指针,数组中的每个对象都可以是一个窗口句柄、事件对象句柄、进程句柄、线程句柄等。

如果你想要等待一个或多个事件发生,可以将这些事件的句柄放入一个数组中,并传递给WaitForMultipleObjects函数。

当任何一个事件发生时,函数就会返回,并告知哪个事件已经发生。

下面是一个简单的示例,演示如何使用WaitForMultipleObjects函数等待两个事件:pascalvarEvents: array[0..1] of THandle;Ret: Longint;beginEvents[0] := CreateEvent(nil, False, False, nil);Events[1] := CreateEvent(nil, False, False, nil);// 等待两个事件中的任何一个发生Ret := WaitForMultipleObjects(2, Events, False, INFINITE);if Ret = WAIT_OBJECT_0 thenShowMessage('Event 1 signaled')else if Ret = WAIT_OBJECT_0 + 1thenShowMessage('Event 2 signaled');end;在上面的示例中,我们创建了两个事件对象,并将它们的句柄存储在Events数组中。

waitforsingleobject函数

waitforsingleobject函数

waitforsingleobject函数waitforsingleobject函数是Windows操作系统中的一个非常重要的函数,它可以用来实现进程间的同步和互斥操作。

在本文中,我们将详细介绍waitforsingleobject函数的使用方法和原理。

waitforsingleobject函数的用法非常简单,它的原型如下: DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);其中,hHandle参数是一个需要等待的内核对象的句柄,可以是进程、线程、事件、信号等;dwMilliseconds参数是等待的时间,如果设置为INFINITE,则表示一直等待,直到有其他线程释放了这个对象。

waitforsingleobject函数的原理是通过阻塞当前线程的方式来等待内核对象的状态变化。

当一个线程调用waitforsingleobject函数时,如果该对象处于未信号状态,则线程会被阻塞,直到该对象变为信号状态。

如果对象已经是信号状态,则线程不会被阻塞,直接返回。

waitforsingleobject函数可以用于实现多种不同的同步和互斥操作。

例如,在多线程编程中,可以使用waitforsingleobject函数来等待某个线程的结束,以便进行下一步操作。

在进程间通信中,可以使用waitforsingleobject函数来等待其他进程发送的信号或事件。

除了waitforsingleobject函数之外,Windows操作系统还提供了许多其他的同步和互斥函数,例如waitformultipleobjects函数、createevent函数、createthread函数等。

这些函数的使用方法和原理类似,但是具体的功能和用法略有不同。

总之,waitforsingleobject函数是Windows操作系统中的一个非常重要的函数,它可以用来实现进程间的同步和互斥操作。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

一下子跳到等待函数WaitForSingleObject, 是因为下面的Mutex、Semaphore、Eve nt、WaitableTimer 等同步手段都要使用这个函数; 不过等待函数可不止WaitForSingl eObject 它一个, 但它最简单.
function WaitForSingleObject(
hHandle: THandle; {要等待的对象句柄}
dwMilliseconds: DWORD {等待的时间, 单位是毫秒}
): DWORD; stdcall; {返回值如下:}
WAIT_OBJECT_0 {等着了, 本例中是: 等的那个进程终于结束了}
WAIT_TIMEOUT {等过了点(你指定的时间), 也没等着}
WAIT_ABANDONED {好不容易等着了, 但人家还是不让咱执行; 这一般是互
斥对象}
//WaitForSingleObject 的第二个参数一般给常数值 INFINITE, 表示一
直等下去, 死等.
WaitForSingleObject 等待什么? 在多线程里就是等待另一个线程的结束, 快来执行自己的代码; 不过它可以等待的对象可不止线程; 这里先来一个等待另一个进程结束的例子,运行效果图:
代码文件:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
var
hProcess: THandle; {进程句柄}
{等待一个指定句柄的进程什么时候结束}
function MyThreadFun(p: Pointer): DWORD; stdcall;
begin
if WaitForSingleObject(hProcess, INFINITE) = WAIT_OBJECT _0 then
Form1.Text := Format('进程 %d 已关闭', [hProcess]);
Result := 0;
end;
{启动一个进程, 并建立新线程等待它的结束}
procedure TForm1.Button1Click(Sender: TObject);
var
pInfo: TProcessInformation;
sInfo: TStartupInfo;
Path: array[0..MAX_PATH-1] of Char;
ThreadID: DWORD;
begin
{先获取记事本的路径}
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
begin
hProcess := pInfo.hProcess; {获取进程句柄}
Text := Format('进程 %d 已启动', [hProcess]);
CreateThread(nil, 0, @MyThreadFun, nil, 0, ThreadID); {建立线程监视}
end;
end;
end.。

相关文档
最新文档