Windows Thread 와 Synchronization(동기화)

#define CALLBACK      __stdcall
#define WINAPI            __stdcall

#define APIENTRY       WINAPI

__stdcall	함수 인자를 제거하는 것이 함수 안에서 수행함을 지시
__cdecl	호출한 곳에서 함수에 전달한 인자를 스택으로부터 제거
CALLBACK	메시지 프로시저, asynchronous procedure call 시 주로 사용
WINAPI	Win32 API 원형, 스레드 시작 함수에 사용
APIENTRY	WinMain 선언시 사용



차 례



---

Thread 관련 함수 Thread 예외처리 MFC Thread Worker Thread UI Thread Fiber 스레드 안의 스레드 (Light Weight Thread) TLS (Thread Local Storage) 1. Win32 TLS 2. 컴파일러 지원 TLS 3. MFC TLS Thread Synchronization (동기화) - 기본 Interlocked~ Volatile Thread Synchronization (동기화) - Win32 1.Critical Section 2.Event 3.Semaphore 4.Mutex Thread Synchronization (동기화) - MFC 1. CSyncObject 2. CCriticalSection 3. CSemaphore 4. CMutex 5. CEvent 6. CSingleLock 7. CMultiLock Windows Scheduler Quentum(퀀텀) 우선순위 기타

Thread 관련 함수

DWORD WINAPI ThreadProc(LPVOID lpParameter); HANDLE WINAPI CreateThread(   __in          LPSECURITY_ATTRIBUTES lpThreadAttributes,                       //스레드 커널 객체 핸들을 자식프로세스와 공유여부 (필요 없으면 NULL)   __in          SIZE_T dwStackSize,                                                           //stack size 지정(0이면 링커 옵션의 reserve,commit 사용)   __in          LPTHREAD_START_ROUTINE lpStartAddress,                         //ThreadProc 함수 지정   __in          LPVOID lpParameter,                  //ThreadProc 함수의 인자값   __in          DWORD dwCreationFlags,                  //Thread 생성 상태. 0 또는 CREATE_SUSPENDED   __out         LPDWORD lpThreadId                  //생성된 Thread의 ID 값 (시스템 전체에서 유일) ); HANDLE hThread = CreateThread(NULL, 0, ThreadProc, (LPVOID)val, 0, &dwId); SuspendThread(hThread);   Thread 일지 중지  실패시 0xFFFFFFFF 리턴, 성공시 SuspendThread 호출 횟수 리턴 ResumeThread(hThread); Thread 재시작 실패시 0xFFFFFFFF 리턴, 성공시 (SuspendThread 호출 횟수 -1) 리턴하며 0일 경우 재시작 SwitchToThread(); 컨텍스트 스위칭을 일으킴 Sleep(0)과 동일. 성공시 nonzero, 실패시 zero Thread 종료 대기 방법1 : STILL_ACTIVE 체크 DWORD dwExitCode; while (GetExitCodeThread(hThread, &dwExitCode) && dwExitCode == STILL_ACTIVE) Sleep(100); //종료 대기 Thread 종료 대기 방법2 : WaitForSingleObject 또는 WaitForMultipleObjects WaitForSingleObject(hThread, INFINITE); WaitForMultipleObjects(1, &hThread, TRUE, INFINITE); ExitThread(0); Thread 강제 종료 방법1 : 비권장 TerminateThread(GetCurrentThread(), 0); Thread 강제 종료 방법2 : 비권장 CloseHandle(hThread);

** thread 함수 사용.cpp

#include <windows.h> #include <tchar.h> #include <iostream> using namespace std; DWORD WINAPI ThreadProc(LPVOID lpParameter) { int val = (int)lpParameter; cout << "[Thread] lpParameter : " << val << endl; /* Thread 강제 종료 방법1 : 비권장 */ ExitThread(0); /* Thread 강제 종료 방법2 : 비권장 */ TerminateThread(GetCurrentThread(), 0); return 0; } int _tmain(int argc, _TCHAR* argv[]) { setlocale(LC_ALL, ""); int val = 3; DWORD dwId; HANDLE hThread = CreateThread(NULL, 0, ThreadProc, (LPVOID)val, 0, &dwId); if (hThread == NULL)  wcout << TEXT("CreateThread Failed") << endl; else { int suspendCount; Sleep(100); /* 생성된 Thread의 ID 값 (시스템 전체에서 유일) */ cout << "dwId : " <<  dwId << endl; /* SuspendThread : Thread 일지 중지  실패시 0xFFFFFFFF 리턴, 성공시 SuspendThread 호출 횟수 리턴 */ suspendCount = SuspendThread(hThread); cout << "suspendCount : " << suspendCount << endl; /* ResumeThread : Thread 재시작 실패시 0xFFFFFFFF 리턴, 성공시 (SuspendThread 호출 횟수 -1) 리턴하며 0일 경우 재시작 */ suspendCount = ResumeThread(hThread); cout << "suspendCount : " << suspendCount << endl; /* SwitchToThread() : 컨텍스트 스위칭을 일으킴 Sleep(0)과 동일. 성공시 nonzero, 실패시 zero */ BOOL bContextSwitch = SwitchToThread(); if (bContextSwitch) cout << "occured context switch : " << bContextSwitch << endl; else cout << "not occured context switch : " << bContextSwitch << endl; /* Thread 종료 대기 방법1 STILL_ACTIVE 체크 */ DWORD dwExitCode; while (GetExitCodeThread(hThread, &dwExitCode) && dwExitCode == STILL_ACTIVE) { Sleep(100); //종료 대기 } /* Thread 종료 대기 방법2 WaitForSingleObject 또는 WaitForMultipleObjects 사용 */ WaitForSingleObject(hThread, INFINITE); WaitForMultipleObjects(1, &hThread, TRUE, INFINITE); CloseHandle(hThread); } return 0; }

CreateThread() 보단 _beginthreadex()를 사용하고 MFC 라면 AfxBeginThread를 사용 한다.

UINT WINAPI ThreadProc(LPVOID lpParameter) {     return 0; } void main() {      //MFC 아닌 경우 #define _MT, #include <process.h> 필요 할 수 있음.     HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, (void*)GetSafeHwnd(), 0, NULL); }

CreateThread가 CRT 라이브러리(C runtime library)를 위한 준비 과정을 해주지 않아 _beginthreadex 를 권장함.

자세한 설명 : http://blog.naver.com/PostView.nhn?blogId=jhlee8379&logNo=30043536742&widgetTypeCall=true

Thread 예외처리

SW적인 예외처리       : try ~ catch

SW/HW적인 예외처리 : __try ~ __except, __try ~ __finally

#include <windows.h> #include <tchar.h> #include <iostream> using namespace std; DWORD WINAPI ThreadProc(LPVOID lpParameter); DWORD InnerThreadProc(LPVOID lpParameter); DWORD HandleException(LPEXCEPTION_POINTERS p); long g_lThreadCnt = 0; BOOL g_bExitThread = FALSE; int _tmain(int argc, _TCHAR* argv[]) { __try { //do something HANDLE hThread = CreateThread(NULL, 0, ThreadProc, (LPVOID)3, NULL, NULL); CloseHandle(hThread); } __except (HandleException(GetExceptionInformation())) //예외정보 HandleException로 전달 { //do something } //실행된 Thread의 정상종료 대기 g_bExitThread = TRUE; while (0 < g_lThreadCnt) Sleep(200); return 0; } DWORD WINAPI ThreadProc(LPVOID lpParameter) { __try { InterlockedIncrement(&g_lThreadCnt); __try { return InnerThreadProc(lpParameter); } __except (HandleException(GetExceptionInformation())) //예외정보 HandleException로 전달 { //do something } } __finally { InterlockedDecrement(&g_lThreadCnt); } return 0; } DWORD InnerThreadProc(LPVOID lpParameter) { //do something while (true) { if (g_bExitThread) break; } return 0; } DWORD HandleException(LPEXCEPTION_POINTERS p) { //예외 로깅 등 추적 정보 처리 //LPEXCEPTION_POINTERS 를 통해 Exception 확인 PEXCEPTION_RECORD ExceptionRecord = p->ExceptionRecord; //예외에 대한 정보 PCONTEXT ContextRecord = p->ContextRecord; //프로세서의 레지스터 데이터 및 프로세서 종속적인 정보 ExceptionRecord->ExceptionCode; //예외코드 ExceptionRecord->ExceptionAddress; //예외발생 주소 //예외 처리 필터 return EXCEPTION_EXECUTE_HANDLER; //__except 블록 실행을 유도 }

MFC Thread

Worker Thread

**. Worker Thread 용 AfxBeginThread 함수

CWinThread* AfxBeginThread(    AFX_THREADPROC pfnThreadProc,    LPVOID pParam,    int nPriority = THREAD_PRIORITY_NORMAL,    UINT nStackSize = 0,    DWORD dwCreateFlags = 0,    LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL  ); UINT ThreadProc(LPVOID lpParameter);  //Worker Thread 함수 정의

**. Worker Thread 기본 사용 구조

UINT ThreadProc(LPVOID lpParameter) { return 0; } void 쓰레드생성하는 함수() { CWinThread* pThread = AfxBeginThread(ThreadProc, 3); }

UI Thread

**. UI Thread 용 AfxBeginThread 함수

CWinThread* AfxBeginThread(    CRuntimeClass* pThreadClass,    int nPriority = THREAD_PRIORITY_NORMAL,    UINT nStackSize = 0,    DWORD dwCreateFlags = 0,    LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL  );

**. UI Thread 기본 사용 구조

  1. Thread용 Class 생성 (class CUIThread)   

//UIThread.h #pragma once #include "afxwin.h" class CUIThread : public CWinThread { DECLARE_DYNCREATE(CUIThread); public: CUIThread(void); ~CUIThread(void); virtual BOOL InitInstance(); virtual BOOL PreTranslateMessage(MSG* pMsg); };

//UIThread.cpp #include "StdAfx.h" #include "UIThread.h" #include "TestWnd.h" IMPLEMENT_DYNCREATE(CUIThread , CWinThread); CUIThread::CUIThread(void)  {} CUIThread::~CUIThread(void){} BOOL CUIThread::InitInstance() { CTestWnd* pFrame = new CTestWnd; pFrame->Create(NULL, _T("UI스레드 윈도우")); pFrame->ShowWindow(SW_SHOW); m_pMainWnd = pFrame; return TRUE; //return CWinThread::InitInstance(); } //메세지 처리시 정의 BOOL CUIThread::PreTranslateMessage(MSG* pMsg) { if (CWinThread::PreTranslateMessage(pMsg)) return TRUE; switch(pMsg->message) { case WM_LBUTTONDOWN: MessageBox(pMsg->hwnd, _T("hi~"), _T("hi caption"), MB_OKCANCEL); return TRUE; } return FALSE; }

DECLARE_DYNCREATE, IMPLEMENT_DYNCREATE 매크로는 동적 생성되어야 하느나 document, view, 자식 프레임 윈도우 클래스에 사용한다. (CObject로 부터 상속받은 클래스에 동적생성 기능을 적용시켜줌)

  2. CUIThread 클래스에서 테스트 용으로 띄울 윈도우 클래스    

//TestWnd.h #pragma once #include "afxwin.h" class CTestWnd : public CFrameWnd { public: CMyframeWnd(void); ~CMyframeWnd(void); };

//TextWnd.cpp #include "StdAfx.h" #include "TestWnd.h" CTestWnd::CMyframeWnd(void)   {} CTestWnd::~CMyframeWnd(void) {}

  3. AfxBeginThread 로 UI thread 생성

#include "UITHREAD.h" ... AfxBeginThread(RUNTIME_CLASS(CUIThread));

**. UI Thread 인자 전달 방법
  suspend로 thread 생성후 멤버 변수 값 세팅으로 인자 전달.
  CUIThread* pThread = (CUIThread*)AfxBeginThread(RUNTIME_CLASS(CUIThread),
                                                                             THREAD_PRIORITY,NORMAL, 0, 
                                                                             CREATE_SUSPENDED);
  if (pThread)
  {
    pThread->lpParameter = 인자 값;
    pThread->ResumeThread();
  }

Fiber 스레드 안의 스레드 (Light Weight Thread)

http://blog.naver.com/drrich?Redirect=Log&logNo=20036276646

http://blog.daum.net/aswip/8429384

TLS (Thread Local Storage)

thread 별로 변수 공유의 목적

TLS 배열 크기 : Windows 200/XP = 1088

TLS 3가지 종료

    1. Win32 TLS

    2. 컴파일러 지원 TLS

    3. MFC TLS

1. Win32 TLS (가장 불편)

TLS 할당     : DWORD TlsAlloc(void);    //성공 : 0~TLS index, 실패 : TLS_OUT_OF_INDEXES(0xFFFFFFFF) TLS 해제     : BOOL TlsFree(DWORD dwTlsIndex);    //성공 : nonzero, 실패 : zero TLS 값 지정 : BOOL TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue);    //성공 : nonzero, 실패 : zero TLS 값 얻기 : LPVOID TlsGetValue(DWORD dwTlsIndex);

Win32 TLS 테스트.cpp

#include <windows.h> #include <tchar.h> #include <iostream> using namespace std; long g_lThreadCnt = 0; DWORD g_dwTls = TLS_OUT_OF_INDEXES; void InnerTreadProc(void) { int val = (int)TlsGetValue(g_dwTls); TCHAR tmp[100]; wsprintf(tmp, _T("TLS val : %d\n"), val); wcout << tmp; } DWORD WINAPI ThreadProc(LPVOID lpParameter) { __try { InterlockedIncrement(&g_lThreadCnt); TlsSetValue(g_dwTls, lpParameter); InnerTreadProc(); } __finally { InterlockedDecrement(&g_lThreadCnt); } return 0; } int _tmain(int argc, _TCHAR* argv[]) { g_dwTls = TlsAlloc(); for (int i=0; i<10; i++) { HANDLE hThread = CreateThread(NULL, 0, ThreadProc, (LPVOID)i, 0, NULL); if (hThread) CloseHandle(hThread); } while (0 < g_lThreadCnt) Sleep(200); TlsFree(g_dwTls); return 0; }

2. 컴파일러 지원 TLS (편리)

TLS 변수 선언 (컴파일 단계에서 .tls 섹션에 통합됨)

__declspec(thread) type variable_name;

컴파일러 지원 TLS.cpp

#include <windows.h> #include <tchar.h> #include <iostream> using namespace std; long g_lThreadCnt = 0; __declspec(thread) int intTLS = 0; void InnerTreadProc(void) { TCHAR tmp[100]; wsprintf(tmp, _T("TLS val : %d\n"), intTLS); wcout << tmp; } DWORD WINAPI ThreadProc(LPVOID lpParameter) { __try { g_lThreadCnt++; intTLS = (int)lpParameter; InnerTreadProc(); } __finally { g_lThreadCnt--; } return 0; } int _tmain(int argc, _TCHAR* argv[]) { for (int i=0; i<10; i++) { HANDLE hThread = CreateThread(NULL, 0, ThreadProc, (LPVOID)i, 0, NULL); if (hThread) CloseHandle(hThread); } while (0 < g_lThreadCnt) Sleep(200); return 0; }

3. MFC TLS (TLS 논리만 갖음)

Win32 TLS의 불편함과 개수 제한을 없앰

    CNoTrackObject 를 상속한 클래스에 사용할 변수 정의

    THREAD_LOCAL(CMFCTLS, g_tls)

MFC TLS 테스트.cpp

... 생략 ... int cnt = 1; class CMFCTLS : public CNoTrackObject { public : HWND hWnd; int val; }; THREAD_LOCAL(CMFCTLS, g_MFCTLS)    //g_MFCTLS라는 변수가 MFC TLS로 선언됨 void InnerThreadProc(void) { TCHAR msg[100]; wsprintf(msg, _T("hi~ val : %d"), g_MFCTLS->val);    //TLS 값 사용 MessageBox(g_MFCTLS->hWnd, msg, _T("caption"), MB_OK);    //TLS 값 사용 } UINT ThreadProc(LPVOID lpParameter) { g_MFCTLS->hWnd = (HWND)lpParameter;    //TLS 값 세팅 g_MFCTLS->val     = cnt++;                         //TLS 값 세팅 InnerThreadProc(); return 0; } void 쓰레드생성하는 함수() { for (int i=0; i<3; i++)     AfxBeginThread(ThreadProc, (LPVOID)GetSafeHwnd()); }

Thread Synchronization (동기화) - 기본

Signal(신호 상태)         : 스레드가 실행 될 수 있는 상태

Nosignal (비신호 상태) : 스레드가 대기하게 되는 상태

Interlocked~

LONG InterlockedIncrement(LONG volatile& lpAddend);         //동작 : lpADdend++, return : 증감 이전 값 LONG InterlockedDecrement(LONG volatile& lpAddend);            //동작 : lpADdend--, return : 증감 이전 값 LONG InterlockedExchangeAdd(LPLONG volatile Addend, LONG value);           //동작 : Addend += value, return : 증감 이전 값 LONG InterlockedExchange(LONG volatile* Target, LONG value);          //동작 : Target = value, return : 이전 값 LONG InterlockedCompareExchange(LONG volatile* Destination, LONG Exchange, LONG Comperand);         //동작 : if (*Destination == Comperand) *Destination = Exchange;, return : 이전 값 PVOID InterlockedExchangePointer(PVOID volatile* Target, PVOID value);         //동작 : Target = value, return : 이전 포인터 PVOID InterlockedCompareExchangePointer(PVOID volatile* Destination, PVOID Exchange, PVOID Comperand);         //동작 : if (Destination == Comperand) Destination = Exchange, return : 이전 포인터

Volatile

릴리즈 모드 같은 최적화에 의해 변수가 고정되는 현상(혹은 증상)을 방지할 수 있게 해준다.

volatile bool isRun = true; while (isRun) {     wcout << _T("running..");     }

Thread Synchronization (동기화) - Win32

1.Critical Section

2.Event

3.Semaphore

4.Mutex

1.Critical Section

작고 빠름.

중복 소유 개념.

프로세스간 비공유

InitializeCriticalSection() : 초기화

EnterCriticalSection() : 소유권 획득(획득시까지 무한 대기)

TryEnterCriticalSection() : 소유권 획득(실패해도 즉시 리턴)

LeaveCriticalSection() : 소유권 해제

DeleteCriticalSection() : 제거

#include <windows.h> #include <tchar.h> #include <iostream> #include <process.h> using namespace std; #define ARRAY_SIZE 100 #define THREAD_SIZE 10 CRITICAL_SECTION g_cs; int g_nIndex = 0; DWORD g_dwTicks[ARRAY_SIZE]; UINT WINAPI ThreadProc(LPVOID lpParameter) { while (true) { EnterCriticalSection(&g_cs); // lock : 최대 30일동안 대기 (중복소유) EnterCriticalSection(&g_cs); // lock : 최대 30일동안 대기 (중복소유) if (g_nIndex < ARRAY_SIZE) { g_dwTicks[g_nIndex] = GetTickCount(); TCHAR msg[100]; wsprintf(msg, _T("%d : %Id (tID:%ld)\n"), g_nIndex, g_dwTicks[g_nIndex], GetCurrentThreadId());  wcout << msg; g_nIndex++; SwitchToThread(); } else { TCHAR msg[100];  wsprintf(msg, _T("end (tID:%ld)\n"), GetCurrentThreadId()); wcout << msg; LeaveCriticalSection(&g_cs);    // lock 해제 (중복소유) LeaveCriticalSection(&g_cs);    // lock 해제 (중복소유) _endthreadex(0); } LeaveCriticalSection(&g_cs);         // lock 해제 (중복소유) LeaveCriticalSection(&g_cs);         // lock 해제 (중복소유) } return 0; } int _tmain(int argc, _TCHAR* argv[]) { InitializeCriticalSection(&g_cs);     //초기화 HANDLE* hThread = new HANDLE[THREAD_SIZE]; for (int i=0; i<THREAD_SIZE; i++) hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, (LPVOID)NULL, 0, NULL); WaitForMultipleObjects(THREAD_SIZE, hThread, TRUE, INFINITE);   //thread 종료 대기 delete hThread; DeleteCriticalSection(&g_cs);         //종료 return 0; }

**. EnterCiriticalSection()은 lock을 소유하지 못하면 최대 30일 동안 대기 한다. 이것을 회피하기 위해 TryEnterCriticalSection()이 제공되며 lock을 소유하지 못할 경우 FALSE를 리턴한다.

    BOOL TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

2.Event

Critical Section에 비해 무거움. 

신호/비신호, 자동/수동 이벤트 개념.

프로세스간 공유.

CreateEvent() : Event 생성

OpenEvent() : CreateEvent로 생성된 이벤트 객채의 핸들을 하나 더 만듦

SetEvent() : 신호 상태로 변경

ResetEvent() : 비신호 상태로 만듦

PulseEvent() : 시그널 상태라면 비시그널 상태로 변경

#include <windows.h> #include <tchar.h> #include <iostream> #include <process.h> using namespace std; #define ARRAY_SIZE 100 #define THREAD_SIZE 10 HANDLE g_hEvent; int g_nIndex = 0; DWORD g_dwTicks[ARRAY_SIZE]; UINT WINAPI ThreadProc(LPVOID lpParameter) { while (true) { //비신호 상태:Critical Section의 EnterCriticalSection에 대응됨 WaitForSingleObject(g_hEvent, INFINITE); if (g_nIndex < ARRAY_SIZE) { g_dwTicks[g_nIndex] = GetTickCount(); TCHAR msg[100];  wsprintf(msg, _T("%d : %Id (tID:%ld)\n"),                            g_nIndex, g_dwTicks[g_nIndex], GetCurrentThreadId()); wcout << msg; g_nIndex++; SwitchToThread(); } else { TCHAR msg[100];  wsprintf(msg, _T("end (tID:%ld)\n"), GetCurrentThreadId());  wcout << msg; SetEvent(g_hEvent);  //신호 상태:Critical Section의 LeaveCriticalSection에 대응됨 _endthreadex(0); } SetEvent(g_hEvent); //신호 상태:Critical Section의 LeaveCriticalSection에 대응됨 } return 0; } int _tmain(int argc, _TCHAR* argv[]) { /* CreateEvent 1번째 인자 : 보안정보 2번째 인자 FALSE  : 자동 리셋 이벤트. WaitFor~로부터 깨어날때 비신호 상태 TRUE   : 수동 리셋 이벤트. WaitFor~로부터 깨어날때 신호   상태 3번째 인자 TRUE   : 신호 상태 FALSE  : 비신호 상태 4번재 인자 : 객체 이름 정의 */ //자동 리셋 이벤트(FALSE), 신호상태(TRUE) //Critical Section의 InitilizeCriticalSection에 대응됨 g_hEvent = CreateEvent(NULL, FALSE, TRUE, NULL);   HANDLE* hThread = new HANDLE[THREAD_SIZE]; for (int i=0; i<THREAD_SIZE; i++) hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, (LPVOID)NULL, 0, NULL); WaitForMultipleObjects(THREAD_SIZE, hThread, TRUE, INFINITE); delete hThread; CloseHandle(g_hEvent);      //Critical Section의 DeleteCriticalSection에 대응됨 return 0; }

**. MsgWaitForMultipleObjects() 

    WaitForSingObject() 의 경우 wait 중에 메세지가 나라오는 경우 deadlock에 걸리는 경우가 발생함. 이때 MsgWaitForMultipleObjects()를 사용하면 wait가 풀리고 메세지를 처리할 수 있음.

HANDLE g_hEvent = NULL; void main() { g_hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); _beginthreadex(...); //thread 실행 SetEvent(g_hEvent); CloseHandle(g_hEvent); } UINT WINAPI ThreadProc(LPVOID lpParameter) { .. MSG msg; while (true) { DWORD dw = MsgWaitForMultipleObjects(1, &g_hEvent, FALSE, INFINITE, QS_ALLINPUT); if (dw == WAIT_OBJECT_0) break; else if (dw == WAIT_OBJECT_0+1) { if (GetMessage(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessage(&msg); } else break; } } .. return (DWORD) msg.wParam; }

3.Semaphore

Critical Section에 비해 무거움.

신호 카운트 개념. (0보다 크면 신호 상태, 0이면 비신호 상태, 음수가 될 수 없으며 최대 신호 카운트보다 클 수 없다.)

프로세스간 공유.

CreateSemaphore() : 생성

OpenSemaphore() : 열기

ReleaseSemaphore() : 해제

#include <windows.h> #include <tchar.h> #include <iostream> #include <process.h> using namespace std; #define ARRAY_SIZE 100 #define THREAD_SIZE 10 HANDLE g_hSemaphore; int g_nIndex = 0; DWORD g_dwTicks[ARRAY_SIZE]; UINT WINAPI ThreadProc(LPVOID lpParameter) { while (true) { //비신호 상태:Critical Section의 EnterCriticalSection에 대응됨 WaitForSingleObject(g_hSemaphore, INFINITE); if (g_nIndex < ARRAY_SIZE) { g_dwTicks[g_nIndex] = GetTickCount(); TCHAR msg[100];  wsprintf(msg, _T("%d : %Id (tID:%ld)\n"),  g_nIndex, g_dwTicks[g_nIndex], GetCurrentThreadId()); wcout << msg; g_nIndex++; SwitchToThread(); } else { TCHAR msg[100];  wsprintf(msg, _T("end (tID:%ld)\n"), GetCurrentThreadId());  wcout << msg; ReleaseSemaphore(g_hSemaphore, 1, NULL); //신호 상태:Critical Section의 LeaveCriticalSection에 대응됨 _endthreadex(0); } ReleaseSemaphore(g_hSemaphore, 1, NULL); //신호 상태:Critical Section의 LeaveCriticalSection에 대응됨 } return 0; } int _tmain(int argc, _TCHAR* argv[]) { /* CreateSemaphore 1번째 인자 : 보안정보 2번째 인자 : 세마포어 초기 카운트(0보다 크면 신호 상태로 생성) 3번째 인자 : 최대 카운트 4번째 인자 : 이름 */ g_hSemaphore = CreateSemaphore(NULL, 10, 10, NULL); HANDLE* hThread = new HANDLE[THREAD_SIZE]; for (int i=0; i<THREAD_SIZE; i++) hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, (LPVOID)NULL, 0, NULL); WaitForMultipleObjects(THREAD_SIZE, hThread, TRUE, INFINITE); delete hThread; CloseHandle(g_hSemaphore);      //Critical Section의 DeleteCriticalSection에 대응됨 return 0; }

**. CreateSemaphore(NULL, 1, 1, NULL); 은 CreateEvent(NULL, FALSE, TRUE, NULL); 과 동일한 효과를 갖는다.

4.Mutex

Critical Section에 비해 무거움.

중복 소유 개념.

프로세스간 공유.

CreateMutex() : 뮤텍스 생성

OpenMutex() : 뮤텍스 이름의 공유를 위한 함수

ReleaseMutex() : 뮤텍스 소유 해제

CloseMutex() : 뮤텍스 해제

#include <windows.h> #include <tchar.h> #include <iostream> #include <process.h> using namespace std; #define ARRAY_SIZE 100 #define THREAD_SIZE 10 HANDLE g_hMutex; int g_nIndex = 0; DWORD g_dwTicks[ARRAY_SIZE]; UINT WINAPI ThreadProc(LPVOID lpParameter) { while (true) { //비신호 상태:Critical Section의 EnterCriticalSection에 대응됨 WaitForSingleObject(g_hMutex, INFINITE); if (g_nIndex < ARRAY_SIZE) { g_dwTicks[g_nIndex] = GetTickCount(); TCHAR msg[100];  wsprintf(msg, _T("%d : %Id (tID:%ld)\n"),  g_nIndex, g_dwTicks[g_nIndex], GetCurrentThreadId()); wcout << msg; g_nIndex++; SwitchToThread(); } else { TCHAR msg[100];  wsprintf(msg, _T("end (tID:%ld)\n"), GetCurrentThreadId());  wcout << msg; ReleaseMutex(g_hMutex); //신호 상태:Critical Section의 LeaveCriticalSection에 대응됨 _endthreadex(0); } ReleaseMutex(g_hMutex); //신호 상태:Critical Section의 LeaveCriticalSection에 대응됨 } return 0; } int _tmain(int argc, _TCHAR* argv[]) { /* CreateMutex 1번째 인자 : 보안정보 2번째 인자 TRUE   : CreateMutex 함수를 호출한 스레드가 초기 생성된 뮤텍스를 소유.(비신호 상태) FALSE  : TRUE 반대(신호 상태) 3번째 인자 : 이름 */ g_hMutex = CreateMutex(NULL, FALSE, NULL); //신호 상태 HANDLE* hThread = new HANDLE[THREAD_SIZE]; for (int i=0; i<THREAD_SIZE; i++) hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, (LPVOID)NULL, 0, NULL); WaitForMultipleObjects(THREAD_SIZE, hThread, TRUE, INFINITE); delete hThread; CloseHandle(g_hMutex);      //Critical Section의 DeleteCriticalSection에 대응됨 return 0; }







Thread Synchronization (동기화) - MFC 

1. CSyncObject

2. CCriticalSection

3. CSemaphore

4. CMutex

5. CEvent

6. CSingleLock

7. CMultiLock

일부 클래스의 생성자와 Lock(), Unlock() 함수는 인자를 받을 수 있다.

#include <afxmt.h> 필요.

1. CSyncObject

순수한 virtual 클래스.

CObject를 상속하며 CCriticalSection, CEvent, CSemaphore, CMutex의 부모 클래스.

2. CCriticalSection

CRITICAL_SECTION을 클래스화한 것으로 실제 m_sect 멤버 변수가 CRITICAL_SECTION이다.

exception 발생시 Unlock() 처리 필요. (이부분에 대해서 좀 더 편리한 CSingleLock 클래스가 있다.)

**. 일반적인 경우

CCriticalSection g_cs; UINT WINAPI ThreadProc(LPVOID)    // thread 함수 { g_cs.Lock(); //do somthing g_cs.Unlock(); return 0; }

**. TryEnterCriticalSection() 이 필요한 경우 CCriticalSection 클래스를 상속하여 Lock()을 재정의 하는 방법으로 사용.

class CTryCriticalSection : public CCriticalSection { public: virtual BOOL Lock(); }; inline BOOL CTryCriticalSection::Lock() { return TryEnterCriticalSection(&m_sect);  //m_sect은 CCriticalSection의 CRITICAL_SECTION object멤버 }

3. CSemaphore

CSemaphore g_se(10, 10); UINT WINAPI ThreadProc(LPVOID)    // thread 함수 { g_se.Lock(); //do somthing g_se.Unlock(); return 0; }

4. CMutex

CMutex g_mu; UINT WINAPI ThreadProc(LPVOID)    // thread 함수 { g_mu.Lock(); //do somthing g_mu.Unlock(); return 0; }

5. CEvent

자동/수동 리셋의 이벤트 종류가 있기 때문에 Unlock()은 직접 구현해야 한다.

class CTestEvent : public CEvent { public : virtual BOOL Unlock(); }; inline BOOL CTestEvent::Unlock() { return SetEvent(); }

6. CSingleLock

WaitForSingleObject() 대용.

CSingleLock은 소멸자에서 Unlock()을 수행하므로 Exception 발생시 Unlock 처리를 별도로 해줄 필요가 없다.

CMutex g_mu; UINT WINAPI ThreadProc(LPVOID) { CSingleLock sLock(&g_mu); sLock.Lock(); //something.. sLock.UnLock(); return 0; }

7. CMultiLock

WaitForMultipleObjects() 대용.

CEvent g_event[10]; UINT WINAPI ThreadProc(LPVOID) { CMultiLock mLock(g_evnet, 10); DWORD dw = mLock.Lock(INFINITE, FALSE); if (WAIT_OBJECT_0 <= dw && dw < (WAIT_OBJECT_0 + 2)) { //.. mLock.Unlock(); } return 0; }

Windows Scheduler

윈도우는 선점형 멀티태스킹의 round-robin 스케쥴링 시스템.

Quentum(퀀텀)

thread가 할당받은 CPU 시간 단위.

Windows 2000 Professional/XP : 6퀀텀 (2 clock 단위 : 20ms)

Windows 2000/2003 Server : 36 퀀텀 (12 clock 단위 : 120ms)

우선순위

0 : 제로 페이지

1~15 : 가변 우선순위. 15개의 가변 수준

16~31 : 고정 우선순위. 16개의 real-time 수준

priority class(우선순위 클래스)

 : 프로세스의 우선순위. CreateProcess()의 여섯번째 인자 혹은 SetPriorityClass() 함수로 지정.

IDLE_PRIORITY_CLASS

BELOW_NORMAL_PRIORITY_CLASS

NORMAL_PRIORITY_CLASS                    (기본)

ABOVE_NORMAL_PRIORITY_CLASS

HIGH_PRIORITY_CLASS

REALTIME_PRIORITY_CLASS

thread priority(스레드 우선순위)

 : thread 의 우선순위. SetThreadPriority()로 지정.

THREAD_PRIORITY_IDLE

THREAD_PRIORITY_LOWEST

THREAD_PRIORITY_BELOW_NORMAL

THREAD_PRIORITY_NORMAL                  (기본)

THREAD_PRIORITY_ABOVE_NORMAL

THREAD_PRIORITY_HIGHEST

THREAD_PRIORITY_TIME_CRITICAL

우선순위 조합 : http://msdn.microsoft.com/en-us/library/ms685100(VS.85).aspx

윈도우 스레드 상태 이미지 출처  : http://www.macdesign.net/academic/it4813/it4813-Submitted/IT4813-u03a1-Process_States.html

기타

TBB (Intel Threading Building Blocks)

멀티 코어 프로세서 시스템 성능 향상을 도와주는 스레드 처리 C++ 라이브러리.

http://studycan.tistory.com/94