An object of class CMutex represents a "mutex" ? a 
synchronization object that allows one thread mutually 
exclusive access to a resource. Mutexes are useful when 
only one thread at a time can be allowed to modify data or 
some other controlled resource. For example, adding nodes 
to a linked list is a process that should only be allowed 
by one thread at a time. By using a CMutex object to 
control the linked list, only one thread at a time can gain 
access to the list.
An object of class CSemaphore represents a "semaphore" ? a 
synchronization object that allows a limited number of 
threads in one or more processes to access a resource. A 
CSemaphore object maintains a count of the number of 
threads currently accessing a specified resource.

Thread is the smallest set of instructions that can be 
executed.

Cmutex and Csemaphore are the ways used for synchronization 
purpose.

the difference between the above two is..Cmutex is a single 
lock where as csemaphore is a multilock..


mutex is used for mutual exclusion while semaphore is a 
synchonozation variabl

CMutex                          CSemaphore
                        
Allows at most one thread  allows more than one thread to 
access the resource(RES)   Access the RES simultaneousl     
y        

Prevents more than one               It allows more that 
one thread 2        
Thread to access the res             access the resource

Using mutex, we can                 Using semaphore, we can 
sync 
Synchronize one/more threads   threads with in the process
In different process or with in
Process.

CMutex is a single lock                CSemaphore is a 
multilock.

CMutex Implementation          CSemaphore Implementation
API’s in CMutex Dev:
::Create Mutex()                        ::CreateSemaphore()
::WaitForSinglrObject()               ::WaitForSinglrObject
()
::WaitForMultipleObject
()             ::WaitForMultipleObject()    
::Release Mutex()                       ::Release Semaphore
()
                                                 ::CloseHand
le()