Re: WaitForSingleObject
"Scott McPhillips [MVP]" <org-dot-mvps-at-scottmcp> ha scritto nel messaggio
news:uxenI48nKHA.4628@TK2MSFTNGP06.phx.gbl...
No, use CRITICAL_SECTION. It has less overhead.
After initializing it (InitializeCriticalSection(&cs)), surround all
accesses to data shared between threads like this:
EnterCriticalSection(&cs);
...access or change shared data
LeaveCriticalSection(&cs);
The first statement suspends the calling thread if another thread is
"inside" a similar code block. When the other thread does the Leave..,.
call the first thread is allowed to proceed.
Ok! I am going to need a little help from you though...here's a typical
scenario of my app:
// Buffer structs "circular"
struct buffer
{
unsigned char data[1024]; // binary data container
int bytesRecorded; // bytes actually written (to read)
int flag; // Empty/filled (enum)
buffer(...); // constructor()
};
struct circular
{
circular_buffer<buffer> cb; // Cicular buffer based on "buffer"
};
// Global maps
map<int, circular> users;
map<int, circular>::iterator uit;
map<int, HANDLE> eventi;
int main()
{
// TODO: launch Producer thread.
(...)
// TODO: Set up server and accept incoming
// requests. Each time a client connects
// spawn a new Consumer thread
(...)
return 0; // never for the moment!
}
// Thread Consumer is launched
// anytime a client conencts.
thread Consumer
{
int threadid = (int)GetCurrentThreadId();
// Create event & push it in the "eventi" map
//
HANDLE hevent = CreateEvent(NULL,0,0,NULL);
eventi.insert(make_pair(threadid, hevent));
// Prepare & add circular buffer to the "users" map
//
circular c;
users.insert(make_pair(threadid, c));
// Loop...
//
while(1)
{
// Callback event
WaitForSingleObject(eventi[threadid], INFINITE);
// TODO: read buffer from "users" map
// and send it to the client. If the
// client disconnect break the while loop
}
// Close & remove event from event map
//
CloseHandle(eventi[threadid]);
eventi.erase(threadid);
// Remove buffer from the map
//
users.erase(threadid);
return 0;
}
// Thread Producer is launched
// once. Its main goal is to write
// the same data to all the Consumer
// threads.
thread Producer
{
while(1)
{
// TODO: write on every
// element of map "users"
//
for(uit=users.begin(); uit!=users.end(); ++uit)
{
users[uit->first].cb.push_back(buffer(...));
// Signal event in the Cosumer
// thread (buffer written).
//
if(eventi[uit->first])
SetEvent(eventi[uit->first]);
}
}
return 0;
}
thanks