www.pudn.com > 200407241203328864.rar > thread.h

#if !defined THREAD_H 
#define THREAD_H 
//------------------------------------ 
//  thread.h 
//  (c) Bartosz Milewski, 1996 
//------------------------------------ 
 
#include  
 
class Thread 
{ 
public: 
    Thread (DWORD (WINAPI * pFun) (void* arg), void* pArg) 
    { 
        _handle = CreateThread ( 
            0, // Security attributes 
            0, // Stack size 
            pFun,  
            pArg,  
            CREATE_SUSPENDED,  
            &_tid); 
    } 
    ~Thread () { CloseHandle (_handle); } 
    void Resume () { ResumeThread (_handle); } 
    void WaitForDeath () 
    { 
        WaitForSingleObject (_handle, 2000); 
    } 
private: 
    HANDLE _handle; 
    DWORD  _tid;     // thread id 
}; 
 
class Mutex 
{ 
    friend class Lock; 
public: 
    Mutex () { InitializeCriticalSection (&_critSection); } 
    ~Mutex () { DeleteCriticalSection (&_critSection); } 
private: 
    void Acquire ()  
    {  
        EnterCriticalSection (&_critSection); 
    } 
    void Release ()  
    {  
        LeaveCriticalSection (&_critSection); 
    } 
 
    CRITICAL_SECTION _critSection; 
}; 
 
class Lock  
{ 
public: 
	// Acquire the state of the semaphore 
	Lock ( Mutex& mutex )  
		: _mutex(mutex)  
	{ 
		_mutex.Acquire(); 
	} 
	// Release the state of the semaphore 
	~Lock () 
	{ 
		_mutex.Release(); 
	} 
private: 
	Mutex& _mutex; 
}; 
 
class Event 
{ 
public: 
    Event () 
    { 
        // start in non-signaled state (red light) 
        // auto reset after every Wait 
        _handle = CreateEvent (0, FALSE, FALSE, 0); 
    } 
 
    ~Event () 
    { 
        CloseHandle (_handle); 
    } 
 
    // put into signaled state 
    void Release () { SetEvent (_handle); } 
    void Wait () 
    { 
        // Wait until event is in signaled (green) state 
        WaitForSingleObject(_handle, INFINITE); 
    } 
    operator HANDLE () { return _handle; } 
private: 
    HANDLE _handle; 
}; 
 
class TrafficLight 
{ 
public: 
    TrafficLight () 
    { 
        // Start in non-signaled state (red light) 
        // Manual reset 
        _handle = CreateEvent (0, TRUE, FALSE, 0); 
    } 
 
    ~TrafficLight () 
    { 
        CloseHandle (_handle); 
    } 
 
    // put into signaled state 
    void GreenLight () { SetEvent (_handle); } 
 
    // put into non-signaled state 
    void RedLight () { ResetEvent (_handle); } 
 
    void Wait () 
    { 
        // Wait until event is in signaled (green) state 
        WaitForSingleObject(_handle, INFINITE); 
    } 
 
private: 
    HANDLE _handle; 
}; 
 
#endif