2016/06/30

1. 임계 영역.

CRITICAL_SECTION CMyCriticalSection::m_CS;
CMyCriticalSection::CMyCriticalSection(void)
{
}

CMyCriticalSection::~CMyCriticalSection(void)
{
}

void CMyCriticalSection::Initialize(void)
{
	InitializeCriticalSection(&m_CS);

	m_hThread = (HANDLE)_beginthreadex(0, 0, ThreadFunc, this, 0, 0);
}

void CMyCriticalSection::Progress(void)
{
	WaitForSingleObject(m_hThread, INFINITE);

	CloseHandle(m_hThread);

	DeleteCriticalSection(&m_CS);
}

unsigned int WINAPI CMyCriticalSection::ThreadFunc(void* _pArg)
{
	CMyCriticalSection* pTemp = (CMyCriticalSection*)_pArg;

	EnterCriticalSection(&m_CS);

	for (int i = 0; i < 10; ++i)
		cout << i << endl;

	LeaveCriticalSection(&m_CS);

	_endthreadex(0);

	return 0;
}

 

2. 뮤텍스. 

HANDLE CMyMutex::m_Mutex;
CMyMutex::CMyMutex(void)
{
}

CMyMutex::~CMyMutex(void)
{
}

void CMyMutex::Initialize(void)
{
	m_Mutex = CreateMutex(NULL, FALSE, NULL);							

	m_hThread = (HANDLE)_beginthreadex(0, 0, ThreadFunc, this, 0, 0);
}

void CMyMutex::Progress(void)
{
	WaitForSingleObject(m_hThread, INFINITE);

	CloseHandle(m_hThread);

	CloseHandle(m_Mutex);												
}

unsigned int WINAPI CMyMutex::ThreadFunc(void* _pArg)
{
	CMyMutex* pTemp = (CMyMutex*)_pArg;

	AcquireMutex(m_Mutex);											

	for (int i = 10; i < 20; ++i)
		cout << i << endl;

	ReleaseMutex(m_Mutex);											

	_endthreadex(0);

	return 0;
}

DWORD CMyMutex::AcquireMutex(HANDLE _Mutex)
{
	return WaitForSingleObject(_Mutex, INFINITE);
}

 

3. 세마포어.

HANDLE CMySemaphore::m_Semaphore;
CMySemaphore::CMySemaphore(void)
{
}

CMySemaphore::~CMySemaphore(void)
{
}

void CMySemaphore::Initialize(void)
{
	m_Semaphore = CreateSemaphore(NULL, 1, 1, NULL);

	m_hThread = (HANDLE)_beginthreadex(0, 0, ThreadFunc, this, 0, 0);
}

void CMySemaphore::Progress(void)
{
	WaitForSingleObject(m_hThread, INFINITE);

	CloseHandle(m_hThread);

	CloseHandle(m_Semaphore);
}

unsigned int WINAPI CMySemaphore::ThreadFunc(void* _pArg)
{
	CMySemaphore* pTemp = (CMySemaphore*)_pArg;

	AcquireSemaphore(m_Semaphore);

	for (int i = 20; i < 30; ++i)
		cout << i << endl;

	ReleaseSemaphore(m_Semaphore, 1, NULL);

	_endthreadex(0);

	return 0;
}

DWORD CMySemaphore::AcquireSemaphore(HANDLE _Semaphore)
{
	return WaitForSingleObject(_Semaphore, INFINITE);
}

 

4. 이벤트.

HANDLE CMyEvent::m_Event;
CMyEvent::CMyEvent(void)
{
}

CMyEvent::~CMyEvent(void)
{
}

void CMyEvent::Initialize(void)
{
	m_Event = CreateEvent(NULL, TRUE, FALSE, NULL);

	m_hThread = (HANDLE)_beginthreadex(0, 0, ThreadFunc, this, 0, 0);
}

void CMyEvent::Progress(void)
{
	SetEvent(m_Event);

	WaitForSingleObject(m_hThread, INFINITE);

	CloseHandle(m_Event);

	CloseHandle(m_hThread);
}

unsigned int WINAPI CMyEvent::ThreadFunc(void* _pArg)
{
	CMyEvent* pTemp = (CMyEvent*)_pArg;

	AcquireEvent(m_Event);

	for (int i = 30; i < 40; ++i)
		cout << i << endl;

	_endthreadex(0);

	return 0;
}

DWORD CMyEvent::AcquireEvent(HANDLE _Event)
{
	return WaitForSingleObject(_Event, INFINITE);
}