Re: MFC threads and critical section
It sounds like you understand.
A CRITICAL_SECTION object is a structure that essentially just keeps track
of which thread owns it.
I imagine it's implemented as a structure because it can only be used by
threads of one process so it is faster than accessing a global
synchronization object (like a mutex).
If you have an object you need thread safe access to, you can use a critical
section something like this (pseudocode):
//--------------------------------------------------------------
// in initialization
allocate a CRITICAL_SECTION (I'll call it MyIntArrayCS)
InitializeCriticalSection(&MyIntArrayCS)
....
// in thread 1
EnterCriticalSection(&MyIntArrayCS)
access the integer array
LeaveCriticalSection(&MyIntArrayCS)
....
// in thread 2
EnterCriticalSection(&MyIntArrayCS)
access the integer array
LeaveCriticalSection(&MyIntArrayCS)
//--------------------------------------------------------------
The executing thread that executes the EnterCriticalSection first takes
ownership of the critical section
It owns it until it releases ownership with LeaveCriticalSection
When another thread tries to acquire ownership of a critical section that is
already owned, the thread is suspended until the critical section is
released by the owning thread.
For more info on practical implementation, I highly recommend reading Joe
Newcomer's essays here:
http://www.flounder.com/mvp_tips.htm#hreads%20and%20Processes%20series
Hope this helped a bit,
Mark
--
Mark Salsbery
Microsoft MVP - Visual C++
"one-trick-pony" <worldofpain.aamir@gmail.com> wrote in message
news:1186505343.016001.204040@g4g2000hsf.googlegroups.com...
Hi,
I am interested in understanding the threads communicaiton behavior
inside an MFC based application. Suppose, an MFC application creates
2 secondary threads. Threads need to update a shared integer array at
times. So when first thread is accessing array, the second thread
should not be allowed access to the array and vice-versa. I am
reading a book on operating systems and main emphasis is on UNIX OS
and I want to make sure I understand the Windows part of it as well.
I did some basic research and it seems Windows provides API that can
take care of synchronization issues for us. It seems like reinventing
the wheel by writing my own code for synchronization since Windows API
solution is well tested and development time is greatly reduced. For
instance, there is an InitializeCriticalSection API. It takes one
argument which is a pointer to the critical section object. Threads
can call EnterCriticalSection which causes wait for ownership of the
specified critical section object in case it is being utilized and
once thread is done it can call LeaveCriticalSection.
I am having difficulty relating hypothetical example above about
granting access to integer array with these API. What is critical
section object? Is it a pointer to function/method/class etc? What is
proper procedure for dealing with above mentioned scenario, ie,
threads sharing a common data memory? A code sample will help or a
skeleton of code.