Re: thread questions
Guys,
I think I found a way to do this..
typedef struct _MYPARAMS {
TCHAR szSubject[MAX_PATH];
HANDLE hEvent;
} MYPARAMS, *LPMYPARANS;
DWORD WINAPI SearchProc(LPVOID lpParameter)
{
LPMYPARAMS p = (LPMYPARAMS) lpParameter;
while (WAIT_TIMEOUT == WaitForSingleObject(p->hNotify, 1000)) {
// do polling here
}
delete p;
return 0;
}
HANDLE DoSearch(LPCTSTR lpszSubject)
{
LPMYPARAMS p = new MYPARAMS;
_tcsncpy(p->szSubject, lpszSubject, MAX_PATH);
p->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
HANDLE hThread = CreateThread(NULL, 0, SearchProc, p, 0, NULL);
CloseHandle(hThread);
return p->hEvent;
}
int _tmain(int argc, _TCHAR* argv[])
{
HANDLE hSearch1 = DoSearch(_T("Some subject"));
if (WAIT_OBJECT_0 == WaitForSingleObject(hSearch1, 3000)) {
// found result within 3 seconds
}
// even if function did not complete in 3 seconds, closing handle will
make WaitForSingleObject in thread terminate so thread can exit!
CloseHandle(hSearch1); // this will terminate the WaitForSingleObject in
the thread and make it terminate!
return 0;
}
So what is wrong with this code?
Normally you would do a WaitForSingleObject on thread handle, to wait for it
to complete before exitting the application. What happens if you prematurely
exit the application? Will thread have chance to complete or will it be
forcefully killed, causing potential memory leaks?
Lisa
"Lisa Pearlson" <no@spam.plz> wrote in message
news:eGIs13qfJHA.5572@TK2MSFTNGP02.phx.gbl...
Hi all,
Imagine I need a function that does a lengthy search.
For this function not to block, it should be implemented to be
asynchronous.
I guess this would be implemented this way:
DWORD WINAPI DoSearch(LPVOID lpParameter)
{
// do some length search here
return 0;
}
HANDLE DoSearch(LPCTSTR lpszSubject)
{
return CreateProcess(... SearchProc ...);
}
I want the ability to have multiple simultaneous searches, e.g.:
HANDLE hSearch1 = DoSearch(_T("Search 1"));
HANDLE hSearch2 = DoSearch(_T("Search 2"));
I could wait for a search to complete this way:
WaitForSingleObject(hSearch1, INFINITE); // wait for completion
CloseHandle(hSearch1); // cleanup
So far, so good...
Now I would like the ability to ABORT the thread, by simply performing a
CloseHandle.
CloseHandle(hSearch2); // abort second search
Normally, I use some event handle or global BOOL value, and pass that to
thread, eg:
BOOL g_bAbort = FALSE;
DWORD WINAPI ThreadProc(LPVOID lpParameter)
{
LPBOOL pBool = (LPBOOL) lpParameter;
while (!pBool) {
// do something
}
return 0;
}
However, this requires a global variable, .. and that complicates the
ability to run copies of the function simultanously (I reckon it requires
a global list that dynamically allocates data to hold reference to each
thread).. I wonder if there is an easy way.
In particular, I am wondering if a thread can be made to abort as soon as
all handles to it have been closed, eg:
CloseHandle(hSearch2); // should abort the thread
Is it possible for a thread to be aware of handles to itself having been
closed?
I assume this can not work:
I assume this will not work:
DWORD WINAPI SomeFunc(LPVOID lpParameter)
{
HANDLE hThread = *(HANDLE*) lpParameter; // will this code execute
BEFORE the local variable in caller is destroyed???
while (<handle is valid>) // what function can be used to know if
handle hasn't been closed by caller? GetHandleInformation?
{
// do something
}
return 0;
}
int main(...)
{
HANDLE hThread; // local variable
hThread = CreateThread(... SomeFunc, &hThread, ...);
}
I hope my lengthy e-mail is clear.. and that someone will be so kind to
answer each of my questions.
Thanks in advance,
Lisa