지나간 삶

int main()
{
    const int size = 1024 * 1024 * 100;    // 100M

    char* p1 = (char*)VirtualAlloc( (void*)0, // 원하는 주소(64k배수), 자동으로 할당 0
                             size*15,            // 원하는 크기(4k 단위)
                             MEM_RESERVE,        // 예약만
                             PAGE_NOACCESS );    // 보호 속성(어짜피 접근못하므로 NOACCESS)

    printf( "예약된 주소 : %p\n", p1 );
    //*p1 = 'a';    // 예약만 된 주소를 사용하는 경우. - RunTime Error 발생..

    char* p2 = p1;
    for( int i = 0; i < 15; ++i )
    {
        getch();

        void* p3 = VirtualAlloc( p2, size, MEM_COMMIT, PAGE_READWRITE );

        printf( "확정된 메모리 : %d\n", p3 );
        p2 = p2 + size;    // 다음 확정할 주소
    }

    VirtualFree( p1, size*15, MEM_DECOMMIT );    // 다시 예약 상태로
    VirtualFree( p1, 0, MEM_RELEASE );        // 다시 Free상태로
                                                                // MEM_RELEASE 지정시 반드시 두번째인자는 0!!
}

/////////////////////////////////////////////////////////////////////////////////////
// exe 로드해서 IMAGE_DOS_HEADER 읽기
int main()
{
    // MMF 1단계 - 화일 Create 또는 Open
    HANDLE hFile = CreateFile(
                               "c:\\windows\\system32\\calc.exe",
                               GENERIC_READ | GENERIC_WRITE,
                               FILE_SHARE_READ,
                               0,
                               OPEN_EXISTING,
                               FILE_ATTRIBUTE_NORMAL, 0 );
    // MMF 2단계 - 화일 매핑 KO 생성
    HANDLE hMap = CreateFileMapping( hFile,        // 연결할 파일
                                     0,                                 // 매핑KO( 섹션 Object ) 보안 속성
                                     PAGE_READONLY,         //
                                     0, sizeof(IMAGE_DOS_HEADER),    // 매핑할 크기
                                     "map" );                        // 매핑 객체 이름

    // MMF 3단계 - 매핑 객체를 사용해서 화일을 가상주소와 연결한다.
    IMAGE_DOS_HEADER* p = (IMAGE_DOS_HEADER*) MapViewOfFileEx( hMap, FILE_MAP_READ,
           0, 0,        // Offset( 파일 생성시는 무조건 0 기존파일 Open시에만 적용 )
           0,           // 크기( 0 매핑 객체에 지정된 크기를 사용 )
           (void*)0x00600000 ); // 원하는 주소

    if ( p == 0 ) printf( "error\n" );
    else
    {
        printf( "매핑된 주소 : %p\n", p );
        printf( "%x\n", p->e_magic );    // 모든 실행 파일은 "MZ" 로 시작한다.
    }
    UnmapViewOfFile( p );
    CloseHandle( hMap );
    CloseHandle( hFile );
}

/////////////////////////////////////////////////////////////////////////////////////
// FILE 로드해서 버퍼처럼 쓰기~
int main()
{
    // MMF 1단계 - 화일 Create 또는 Open
    HANDLE hFile = CreateFile( "a.txt", GENERIC_READ | GENERIC_WRITE,
                               FILE_SHARE_READ,
                               0,
                               CREATE_ALWAYS,
                               FILE_ATTRIBUTE_NORMAL, 0 );
    // MMF 2단계 - 화일 매핑 KO 생성
    HANDLE hMap = CreateFileMapping( hFile,        // 연결할 파일
                                     0,            // 매핑KO( 섹션 Object ) 보안 속성
                                     PAGE_READWRITE,    //
                                     0, sizeof(IMAGE_DOS_HEADER),    // 매핑할 크기
                                     "map" );    // 매핑 객체 이름

    // MMF 3단계 - 매핑 객체를 사용해서 화일을 가상주소와 연결한다.
    char* p = (char*) MapViewOfFileEx( hMap, FILE_MAP_WRITE,
           0, 0,        // Offset( 파일 생성시는 무조건 0 기존파일 Open시에만 적용 )
           0,           // 크기( 0 매핑 객체에 지정된 크기를 사용 )
           (void*)0x00600000 ); // 원하는 주소

    if ( p == 0 ) printf( "error\n" );
    else
    {
        printf( "매핑된 주소 : %p\n", p );

        strcpy( p, "Hello" );    // 파일에 출력
        p[40] = 'C';
    }
    UnmapViewOfFile( p );
    CloseHandle( hMap );
    CloseHandle( hFile );
}

//-------------------------------------------------------------------------------
// A.cpp - 좌표를 pagefile에 써준다.
struct LINE
{
    POINTS ptFrom;
    POINTS ptTo;
};

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HANDLE hEvent, hMap, hEvent2;
    static POINTS ptFrom, ptTo;
    static LINE* pLine;

    switch( msg )
    {   
    case WM_CREATE:
        {
            hEvent = CreateEvent( 0, 0, 0, "e1" );
            hEvent2 = CreateEvent( 0, 0, TRUE, "e2" );

            // 매핑 객체 생성
            hMap = CreateFileMapping( (HANDLE)-1, // Page 화일을 사용하라.
                                      0, PAGE_READWRITE,
                                      0, sizeof(LINE), "map" );
            pLine = (LINE*) MapViewOfFile( hMap, FILE_MAP_WRITE, 0, 0, 0 );
        }
        return 0;

    case WM_LBUTTONDOWN:
        ptFrom = ptTo = MAKEPOINTS( lParam );
        return 0;
    case WM_MOUSEMOVE:
        if( wParam & MK_LBUTTON )
        {
            POINTS pt = MAKEPOINTS( lParam );
            HDC hdc = GetDC( hwnd );

            MoveToEx( hdc, ptFrom.x, ptFrom.y, 0 );
            LineTo  ( hdc, pt.x, pt.y );

            ReleaseDC( hwnd, hdc );

            // MMF에 넣는다.
            WaitForSingleObject( hEvent2, INFINITE ); // 꺼내 갔는가를 확인..

            pLine->ptFrom = ptFrom;
            pLine->ptTo = pt;

            // Event Signal
            SetEvent( hEvent );

            ptFrom = pt;
        }
        return 0;

    case WM_DESTROY:
        UnmapViewOfFile( pLine );
        CloseHandle( hEvent );
        CloseHandle( hMap );

        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}
//-------------------------------------------------------------------------------
// B.cpp - A.cpp 에서 입력한 pagefile을 읽는다.
struct LINE
{
    POINTS ptFrom;
    POINTS ptTo;
};

DWORD WINAPI Work( void* p )
{
    HWND hwnd = (HWND)p;
    HANDLE hEvent = OpenEvent( EVENT_ALL_ACCESS, 0, "e1" );
    HANDLE hEvent2 = OpenEvent( EVENT_ALL_ACCESS, 0, "e2" );

    HANDLE hMap   = OpenFileMapping( FILE_MAP_ALL_ACCESS, 0, "map" );

    LINE* pLine = (LINE*) MapViewOfFile( hMap, FILE_MAP_READ, 0, 0, 0 );

    while( 1 )
    {
        WaitForSingleObject( hEvent, INFINITE );
       
        // 약간의 지연이 발생..
        Sleep(10);

        // 이제 MMF에서 꺼내서 그린다.
        HDC hdc = GetDC( hwnd );

        MoveToEx( hdc, pLine->ptFrom.x, pLine->ptFrom.y, 0 );
        LineTo( hdc,   pLine->ptTo.x,   pLine->ptTo.y );

        // 꺼내 갔음을 알려준다.
        SetEvent( hEvent2 );

        ReleaseDC( hwnd, hdc );
    }
    return 0;
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {   
    case WM_CREATE:
        CloseHandle( CreateThread( 0, 0, Work, (void*)hwnd, 0, 0 ) );
        return 0;

    case WM_LBUTTONDOWN:
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

// spy.dll 만들기~
WNDPROC old;
// 계산기의 메세지 처리함수를 가로챌 함수

LRESULT CALLBACK foo( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch( msg )
    {
    case WM_COMMAND:    // 메뉴 선택
        switch( LOWORD(wParam) )
        {
        case 304:    //    "공학용" 메뉴
            MessageBox( 0, "^^", "", MB_OK );
            return 0;
        }
        break;
    }
    // 나머지 메세지는 모두 원래의 함수로 보낸다.
    return CallWindowProc( old, hwnd, msg, wParam, lParam );
}

// DLL이 프로세스에 매핑될때 자동으로 호출되는 함수
BOOL WINAPI DllMain( HANDLE h, DWORD r, LPVOID how )
{
    if ( r == DLL_PROCESS_ATTACH )
    {
        HWND hwnd = FindWindow( 0, "계산기" );

        old = (WNDPROC)SetWindowLong( hwnd, GWL_WNDPROC, (LONG)foo );
    }
    return TRUE;    // 반드시 TRUE를 리턴.
}

////////////////////////////////////////////////////////////////////////////////
// DLLInject.cpp
void DLLInject( DWORD pid, const char* path )
{
    HANDLE hProcess = OpenProcess( PROCESS_ALL_ACCESS, 0, pid );

    ///////////////////////////////////////////////////////////
    // LoadLibrary 의 주소를 찾는다.
    HMODULE hDll = GetModuleHandle( "Kernel32.dll" );

    PTHREAD_START_ROUTINE f = (PTHREAD_START_ROUTINE)
                                GetProcAddress( hDll, "LoadLibraryA" );

    // PTHREAD_START_ROUTINE 은 미리 정의된 스레드 함수 포인터 type이다.
    void* p = VirtualAllocEx( hProcess, 0, strlen(path)+1, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE );

    // Inject 할 DLL의 경로를 계산기 메모리에 복사해 놓는다.
    DWORD len;
    WriteProcessMemory( hProcess, p, path, strlen(path)+1, &len );

    ///////////////////////////////////////////////////////////
    // 다른 프로세스에 스레드를 생성한다.
    HANDLE hThread = CreateRemoteThread( hProcess, 0, 0,
                                         f, (void*)p,        // 함수, 파라미터
                                         0, 0 );
}

int main()
{
    HWND hwnd = FindWindow( 0, "계산기" );

    if ( hwnd == 0 )
    {
        printf( "계산기 부터 실행하세요..\n" );
        return 0;
    }
    // 계산기 프로세스에 DLL을 강제로 넣는다.
    DWORD pid;
    DWORD tid = GetWindowThreadProcessId( hwnd, &pid );

    DLLInject( pid, "C:\\spy.dll" );
}

// 정적 TLS의 문제점 : DLL에 만들고.. 해당 DLL을 LoadLibrary로 사용하면 TLS에 있는 변수가
//                   제대로 동작하지 않는다. => 동적 TLS를 사용하자.                   

// 3의 배수를 차례대로 리턴하는 함수
// single Thread에서는 문제없다.
int Next3Times()
{
    // 정적 TLS : static 지역 변수 혹은 전역 변수에만 사용가능..
    __declspec(thread) static int n = 0;
    n = n + 3;
    return n;
}

DWORD WINAPI foo( void* p )
{
    char* n = (char*)p;

    printf( "%s : %d\n", n, Next3Times() );
    printf( "%s : %d\n", n, Next3Times() );
    printf( "%s : %d\n", n, Next3Times() );

    return 0;
}

int main()
{
    HANDLE h[2];
    h[0] = CreateThread( 0, 0, foo, "A", 0, 0 );
    h[1] = CreateThread( 0, 0, foo, "\tB", 0, 0 );

    getch();
}

// 전역변수( 모든 스레드 공유 )로 TLS Index를 보관한다.
DWORD index = 0;

int Next3Times()
{
    DWORD n = (DWORD)TlsGetValue( index ); // TLS에서 값을 꺼내서
    n = n + 3;  // 증가하고
    TlsSetValue( index, (LPVOID) n );    // 다시 보관한다.

    return n;
}

DWORD WINAPI foo( void* p )
{
    // TLS 초기값을 설정한다.
    TlsSetValue( index, 0 );

    char* n = (char*)p;

    printf( "%s : %d\n", n, Next3Times() );
    printf( "%s : %d\n", n, Next3Times() );
    printf( "%s : %d\n", n, Next3Times() );

    return 0;
}

int main()
{
    // 스레드를 생성하기 전에 동적으로 TLS의 빈 슬롯(4byte)을 할당한다.
    index = TlsAlloc();

    HANDLE h[2];
    h[0] = CreateThread( 0, 0, foo, "A", 0, 0 );
    h[1] = CreateThread( 0, 0, foo, "\tB", 0, 0 );

    WaitForMultipleObjects( 2, h, TRUE, INFINITE );

    TlsFree( index );  // TLS를 해지한다.
}

void get_thread_time( HANDLE hThread, __int64* usertime, __int64* kerneltime )
{
    // 스레드의 생성시간, 종료시간, 커널시간, user시간을 구한다.
    __int64 t1, t2;

    GetThreadTimes( hThread, (FILETIME*)&t1,    // 생성시간
                             (FILETIME*)&t2,    // 종료시간
                             (FILETIME*)kerneltime,    // 커널에서 실행한 시간
                             (FILETIME*)usertime );     // 유저모드에서 실행한 시간

}
int factorial( int a )
{
    if( a == 1 ) return 1;

    return a * factorial( a-1 );
}

int main()
{
    __int64 k1 = 0, k2 = 0, u1 = 0, u2 = 0;

    get_thread_time( GetCurrentThread(), &u1, &k1 );

    // 시간을 측정하고 싶은 알고리즘
    for ( int i = 0; i < 1000; ++i )
        printf( "%d\n", factorial(10) );

    get_thread_time( GetCurrentThread(), &u2, &k2 );

    printf( "걸린시간 : %d ms\n", ( (u2-u1) + (k2-k1))/10);
}

#include <commctrl.h> // 공용 컨트롤 헤더
// 스레드간 메세지 통신...
DWORD WINAPI foo( void* p )
{
    TCHAR szApp[] = _T("BBB");

    ATOM atom;
    WNDCLASS wc;
    HWND hwnd;
    MSG msg;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hbrBackground= (HBRUSH)GetStockObject( WHITE_BRUSH );
    wc.hCursor        = LoadCursor( 0, IDC_ARROW );
    wc.hIcon        = LoadIcon( 0, IDI_APPLICATION);
    wc.hInstance    = GetModuleHandle(0);
    wc.lpfnWndProc  = WndProc;
    wc.lpszClassName= szApp;
    wc.lpszMenuName = 0;
    wc.style        = 0;
    atom = RegisterClass( &wc);
   
    if ( atom == 0 )
    {
        MessageBox( 0, _T("Fail To RegisterClass"), _T("Error"), MB_OK);
        return 0;
    }
    hwnd = CreateWindowEx( 0, szApp, szApp, WS_OVERLAPPEDWINDOW,
                                CW_USEDEFAULT, 0, CW_USEDEFAULT,0, 0, 0,
                                0, 0);
    ShowWindow( hwnd, SW_SHOW);
    UpdateWindow( hwnd );

    while ( GetMessage( &msg, 0, 0, 0) )
    {                           
        TranslateMessage(&msg);
        DispatchMessage( &msg);
    }

    return 0;
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hPrg;

    switch( msg )
    {   
    case WM_CREATE:
       
        hPrg = CreateWindow( PROGRESS_CLASS, "", WS_CHILD | WS_VISIBLE | WS_BORDER,
                                10,10,500,30, hwnd, (HMENU)1, 0,0);
        SendMessage( hPrg, PBM_SETRANGE32,0,1000);
        return 0;
    case WM_LBUTTONDOWN:
        {
            HANDLE h = CreateThread( 0, 0, foo, (void*)hwnd, 0, 0);

        }
        return 0;
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

// 스레드간 메세지 통신...
DWORD WINAPI foo( void* p )
{
    HWND hwnd = (HWND)p;

    for ( int i=0; i< 1000; ++i )
    {
       // 생성된 프로그레스바에 메시지를 보낸다.
       SendMessage( hPrg, PBM_SETPOS, i, 0);
       Sleep(10);

        // 주스레드에 직접 메세지를 보내서 자신을 스스로 Update가 되게 하다.
        BOOL b = PostMessage( hwnd, WM_USER+100, i, 0);
        if ( b == FALSE ) break;
        Sleep( 10 );
    }
    return 0;
}

LRESULT CALLBACK WndProc( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hPrg;

    switch( msg )
    {   
    case WM_CREATE:
       
        hPrg = CreateWindow( PROGRESS_CLASS, "", WS_CHILD | WS_VISIBLE | WS_BORDER,
                                10,10,500,30, hwnd, (HMENU)1, 0,0);
        SendMessage( hPrg, PBM_SETRANGE32,0,1000);
        return 0;

        case WM_RBUTTONDOWN:
            {
                while(1);
            }
            return 0;

    case WM_LBUTTONDOWN:
        {
            HANDLE h = CreateThread( 0, 0, foo, (void*)hwnd, 0, 0);

        }
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProc( hwnd, msg, wParam, lParam);
}

// 일반 전역 변수..  .data section에 놓인다. 기본적으로 COW하는 속성을 가지고 있다.
int x = 0;

// exe에 새로운 data 섹션을 만든다.
#pragma data_seg("AAA")
int y = 0;      // 공유 섹션으로 만드려면 반드시 초기값이 필요하다.
#pragma data_seg()

// 특정 섹션의 속성을 지정한다. - Read, Write, Share( COW 속성이 제거된다. )
#pragma comment( linker, "/section:AAA,RWS")    // Copy On Write

int main()
{
    ++x;    ++y;

    if( y >= 3 )
    {
        printf( "3번 이상은 실행하지 마세요\n" );
        --y;
        return 0;
    }

    printf( "x = %d, y = %d\n", x, y );

    _getch(); 
}

// SHARED.dll만들기
// 공유 메모리는 반드시 초기화 해야 한다.,!!!!!!!!!!!!!!
#pragma data_seg("SHARED")
char buf[1024] = { 0 };
#pragma data_seg()

#pragma comment( linker, "/section:SHARED,RWS" )
/////////////////////////////////////////////////////

extern "C" __declspec(dllexport) void SetData(char* s)
{
    strcpy( buf, s );
}
extern "C" __declspec(dllexport) void GetData(char* s)
{
    strcpy( s, buf );
}
/////////////////////////////////////////////////////////////////////////////
// A.cpp
typedef void(*F)(char*);
int main()
{
    HMODULE hDll = LoadLibrary( "SHARED.dll" );
    F SetData = (F)GetProcAddress( hDll, "SetData" );
    F GetData = (F)GetProcAddress( hDll, "GetData" );

    HANDLE hEvent = CreateEvent( 0, 0, 0, "e" );
    HANDLE hEvent2 = CreateEvent( 0, 0, TRUE, "e2" ); // 최초의 signal은 통과해라.

    while( 1 )
    {
        char buf[256] = { 0 };

        WaitForSingleObject( hEvent, INFINITE );

        // DLL의 공유 버퍼에서 Data를 꺼낸다.
        GetData( buf );

        SetEvent( hEvent2 );

        printf( "읽어온 data : %s\n", buf );
    }
}
///////////////////////////////////////////////////////////////////////////
// B.cpp
typedef void(*F)(char*);

int main()
{
    HMODULE hDll = LoadLibrary( "SHARED.dll" );
    F SetData = (F)GetProcAddress( hDll, "SetData" );
    F GetData = (F)GetProcAddress( hDll, "GetData" );

    HANDLE hEvent = CreateEvent( 0, 0, 0, "e" );
    HANDLE hEvent2 = CreateEvent( 0, 0, TRUE, "e2" ); // 최초의 signal은 통과해라.
   
    while( 1 )
    {
        char buf[256] = { 0 };
        gets( buf );    // 1줄입력

        // 정말 가져 갔는지 확인한다.
        WaitForSingleObject( hEvent2, INFINITE );

        SetData( buf );

        // 대기중인 스레드를 깨운다.
        SetEvent( hEvent );
    }
}

// 뮤텍스 : 자원의 독점.. 다중 프로세스의 다중 스레드 동기화
int main()
{
    HANDLE h = CreateMutex(
        0,          // 보안속성
        FALSE,      // 소유권 여부
        "m"         // 이름 - 생략가능
        );

    if( h == 0 )
        printf( "뮤텍스를 만들수 없다.\n");
    else
    {
        // Createxxx() 함수로 KO를 생성했을 떄 Create or Open 인지 알고 싶다면.
        // LastErrorCode를 확인한다.
        if( GetLastError() == ERROR_ALREADY_EXISTS )
            printf( " 뮤텍스를 open 했습니다.\n" );
        else
            printf( "뮤텍스를 create 했습니다.\n" );
    }
    printf("뮤텍스 대기\n");

    // 재귀 횟수를++; 소유권을 획득 한다. --Mutex.signalState
    DWORD ret = WaitForSingleObject( h, INFINITE );
    if( ret == WAIT_OBJECT_0 )  // 정상적으로 signal이 된 경우
        printf("뮤텍스 획득\n");
    else if( ret == WAIT_ABANDONED )
        printf("포기된 뮤텍스\n");
    else if( ret == WAIT_TIMEOUT )
        printf("대기 시간 종료\n");
    else if( ret == WAIT_FAILED )
        printf("Wait에 전달된 핸들이 잘못됨\n");

    getch();

    // 뮤텍스의 소유자는 뮤텍스의 signal 상태와 상관없이 wait를 통과할 수 있다.
    // 자신의 주머니에 열쇠가 있는데 다시 열쇠를 찾는 상황( DeadLock의 위험.. )
    //WaitForSingleObject( h, INFINITE );
    //printf("뮤텍스 획득\n");
    //getch();

  // ReleaseMutex를 하지 않는다면 포기된 뮤텍스가 발생한다.
   // ReleaseMutex( h );      // 재귀횟수--; 소유권을 반납.. ++Mutex.signalState
    CloseHandle( h );
}

  // Limit가 1인 세마포어는 뮤텍스와 비슷하다. 하지만 차이가 있다.
    // 뮤텍스 : 소유권 개념을 가진다. 자원을 획득한 스레드만 자원 반납이 가능하다.
    // 세마포어 : 소유의 개념이 없다. - count의 감소와 증가를 서로 다른 스레드가 해도 된다
int main()
{
    HANDLE h = CreateSemaphore(
        0,      // 보안
        3,      // 카운트의 현재값 ( signalstate = 3 )
        3,      // 카운트 최대값   ( limit = 3 )
        "s" );  // 이름

    printf( "세마포어를 대기합니다.\n" );

    WaitForSingleObject( h, INFINITE ); // --signalstate

    printf( "세마포어 획득\n" );

    getch();

    LONG old;
    // 대부분 1을 증가한다. limit이상의 값은 의미가 없다.
    ReleaseSemaphore( h, 1, &old );     // signalstate += 2번째 인자만큼..

    CloseHandle( h );.
}

// SetEvent.cpp
int main()
{
    HANDLE h = CreateEvent(
        0,      //보안
        FALSE,  // Reset의 종류( T:manual, F:auto )
        FALSE,  // 초기 signal 상태
        "e" );  // 이름

    while( 1 )
    {
        getch();

        SetEvent( h );  // Event를 Signal 상태로 한다.
                        // 결국 커널 함수인 KeSetEvent()를 호출하게 된다.
    }
    CloseHandle( h );
}

////////////////////////////////////////////////////////////////////////////////
// Event.cpp  이벤트 signal이 오기를 기달린다.
int main()
{
    HANDLE h = CreateEvent(
        0,      //보안
        FALSE,  // Reset의 종류( T:manual, F:auto )
        FALSE,  // 초기 signal 상태
        "e" );  // 이름

    printf("Event를 대기 합니다.\n");

    WaitForSingleObject( h, INFINITE );
    printf("Event 획득\n");

    CloseHandle( h );
}

queue<int> Q;   // 생산자와 소비자가 공유할 Q( 전역변수, 모든 data멤버를 스레드가 공유)
HANDLE hMutex;  // 접근을 동기화 하기 위해 사용한다.
HANDLE hSemaphore;  // Q에 이쓴ㄴ 자원의 갯수를 파악한다.(Empty일 경우를 대비)

// 생산자
DWORD WINAPI Produce(void* p)
{
    static int n = 0;

    while( 1 )
    {
        ++n;

        // Q에 대한 독점권을 획득한다.
        WaitForSingleObject( hMutex, INFINITE );
        ///////////////////////////////////////////////
        Q.push( n );  //생산
        printf("생산자 : %d\n", n );

        // 세마포어의 카운트를 올려준다.
        LONG old;
        ReleaseSemaphore( hSemaphore, 1, &old );
        //////////////////////////////////////////////
        // Q에 대한 독점권을 반납한다.
        ReleaseMutex( hMutex );

        Sleep( (rand() % 100) * 30 );    // 0~3초간 대기
    }
    return 0;
}

// 소비자
DWORD WINAPI Consume( void* p )
{
    while( 1 )
    {       
        // Q에 자원이 있는지를 파악한다. - 세마포어
        WaitForSingleObject( hSemaphore, INFINITE );
        // Q에 대한 독점권을 획득한다.
        WaitForSingleObject( hMutex, INFINITE );

        ///////////////////////////////////////////////
        int n = Q.front();
        Q.pop();
        printf("               소비자 : %d\n", n );
        //////////////////////////////////////////////
        // Q에 대한 독점권을 반납한다.
        ReleaseMutex( hMutex );

        Sleep( ( rand() % 100 ) * 30 );
    }
    return 0;
}

int main()
{
    // 생산자 소비자가의 Q의 동기화를 위해서 뮤텍스(크리티컬섹션)사용
    hMutex = CreateMutex( 0, 0, 0 );    // 이름이 필요없으면 0.

    // 초기 카운트 0, 최대 카운트 1000(Q의 크기)의 세마포어..
    hSemaphore = CreateSemaphore( 0, 0, 1000, 0 );

    srand( time(0) );
    HANDLE h[2];

    h[0] = CreateThread( 0, 0, Produce, 0, 0, 0 );
    h[1] = CreateThread( 0, 0, Consume, 0, 0, 0 );

    WaitForMultipleObjects( 2, h, TRUE, INFINITE );
}

// thread-safe class 만들기
// slist는 내부적으로 동기화를 해주게 된다.
// 이는 VC2005 내부적으로 구현이 되어 있다.

template<typename T> class slist
{
    CRITICAL_SECTION cs;

public:
    virtual void Lock() { EnterCriticalSection( &cs ); }
    virtual void Unlock() {  LeaveCriticalSection( &cs ); }
    void push_front( const T& n )
    {
        Lock();
        //....
        Unlock()
    }

    void pop_front()
    {
        Lock();
        //...
        Unlock();
    }
};

// 동기화가 싫다면 상속을 받아서 virtual 의 작업을 아무것도 하지 못하게 한다.
template<typename T> class slist_nosync : public slist<T>
{
    virtual void Lock() {}
    virtual void Unlock() {}
};

class UseCriticalSection
{
public:
    UseCriticalSection() { InitializeCriticalSection( &cs ); }
    ~UseCriticalSection() { DeleteCriticalSection( &cs ); }

    virtual void Lock() {  EnterCriticalSection( &cs ); }
    virtual void Unlock() { LeaveCriticalSection( &cs );  }
};
class NoThread
{
public:
    virtual void Lock() {}
    virtual void Unlock() {}
};
// 단위 전략 기반의 설계 기술.
template<typename T, typename ThreadModel = NoThread> class slist
{
    ThreadModel Sync;

public:
    virtual void Lock() { Sync.Lock(); }
    virtual void Unlock() {  Sync.Unlock(); }
    void push_front( const T& n )
    {
        Lock()
        //....
        Unlock()
    }

    void pop_front()
    {
        Lock();
        //...
        Unlock();
    }
};

slist< int, UseCriticalSection > s;

typedef void(*WORK)();  // 작업의 모양 - 결국 함수 포인터

queue<WORK> Q;  // 작업 Q ( VC2005의 STL은 스레드 안전하므로 동시접근해도 된다. )

BOOL bContinue = TRUE;

HANDLE hSemaphore;

// Thread Pool 에 놓인 모든 스레드가 실행하는 함수
DWORD WINAPI ThreadFunc( void* p )
{
    while( bContinue )
    {
        // 작업 Q에 작업이 들어 올때 까지 대기한다.
        WaitForSingleObject( hSemaphore, INFINITE );

        // Q에서 작업을 꺼낸다.
        //-------------------------------
        // 동기화가 필요하다!!!!!!!!!!
        WORK w = Q.front();
        Q.pop();
        //-------------------------------

        w(); // 작업을 수행한다.
    }
    return 0;
}
// 작업 Q에 작업을 넣는 함수.
void AddWork( WORK f )
{
    Q.push( f );

    LONG old;
    ReleaseSemaphore( hSemaphore, 1, &old );
}
// Pool을 초기화 한다.
void InitPool( int n )
{
    hSemaphore = CreateSemaphore( 0, 0, 1000, 0 );

    for( int i = 0; i < n; ++i )
        CloseHandle( CreateThread( 0, 0, ThreadFunc, 0, 0, 0 ) );
}
//--------------------------------------------------
// Pool에서 작업할 함수
void foo()
{
    for( int i = 0; i < 20; ++i )
    {
        printf( "%d : %d\n", GetCurrentThreadId(), i );
        Sleep(1000);
    }
}

int main()
{
    InitPool( 3 );

    // Pool에 작업을 넣는다.
    AddWork( foo ); AddWork( foo ); AddWork( foo );
    AddWork( foo ); AddWork( foo ); AddWork( foo );

    printf( "main...\n" );

    getch();
}

DWORD WINAPI Monitor( void* p )
{
    DWORD pid = (DWORD)p;

    HANDLE hProcess = OpenProcess( SYNCHRONIZE, 0, pid );
    HANDLE hEvent = OpenEvent( EVENT_ALL_ACCESS, 0, // 상속가능여부
                                   "EXIT_EVENT" );  // 이름

    HANDLE h[2] = { hEvent, hProcess };
    DWORD ret = WaitForMultipleObjects( 2, h, FALSE, INFINITE );

    if( ret == WAIT_OBJECT_0 )  // h[0] 즉 event signal
        printf("Event가 signal이 되어서 종료합니다.");
    else if( ret == WAIT_OBJECT_0+1 ) // h[1] .. +63까지 가능..
        printf("\n %d 프로세스가 종료되었습니다. \n", pid );

    CloseHandle( hEvent );
    CloseHandle( hProcess );

    return 0;
}

int main()
{
    // 새롭게 생성되는 스레드와 통신하기 위한 manual Event
    HANDLE hEvent = CreateEvent( 0, TRUE, 0, "EXIT_EVENT" );
    int count = 0;
    HANDLE hThread[100];

    while( 1 )
    {
        int n;
        printf("대기할 프로세스 ID >> " );
        scanf("%d", &n);

        if ( n == -1 ) break;   // 루프 탈출

        // 새로운 스레드를 생성해서 감시를 하게 한다.
        hThread[count++] = CreateThread( 0, 0, Monitor, (void*)n, 0, 0 );
    }

    // 모든 작업중인 스레드를 깨워서 종료되게 한다.
    SetEvent( hEvent );

    // 모든 스레드가 죽을때까지 대기!!
    WaitForMultipleObjects( count, hThread, TRUE, INFINITE );
    for( int i = 0; i < count; ++i )    CloseHandle( hThread[i] );

    return 0;
}

void Delay() { for( int i = 0; i < 10000000; ++i); }

BOOL bWait = TRUE;

// win32 스레드 함수의 모양
DWORD CALLBACK foo( void* p )
{
    char* n = (char*)p;
    int x = 0;

    for ( int i = 0; i < 1000; ++i )
    {
        x = 100;    Delay();
        x = x + 1;    Delay();

        printf( "%s : %d\n", n, x );
    }

    printf( "%s Finish\n", n );
    bWait = FALSE;
    return 0;
}

int main()
{
    //    foo( "A" );    // 호출

    DWORD tid;

    HANDLE h1 = CreateThread(
        0,        // 보안속성
        0,        // stack 크기
        foo,    // 스레드로 실행할 함수
        "A",    // 인자
        0,        // 우선순위 | 플래그
        &tid    // 생성된 스레드 ID를 담아올 변수(win2000 에서는 0 가능)
        );

    WaitForSingleObject( h1, INFINITE );

//    while( bWait );    // 최악의 코드.. 할일이 없는데 CPU를 사용한다.

//    printf("main....\n");
//    ExitThread(0);    // 현재 스레드(주스레드)만 종료한다. - 프로세스 종료가 아니다.
}

void Delay() { for( int i = 0; i < 10000000; ++i); }

DWORD CALLBACK foo( void* p )
{
    char* n = (char*)p;
    static int x = 0;

    for ( int i = 0; i < 20; ++i )
    {
        //EnterCriticalSection( &cs );    // cs영역에 들어가는 것. cs는 1개의 스레드만 들어간다.
        if( TryEnterCriticalSection( &cs ) )    // win2000 전용함수
        {
        //////////////////////////////////////
        x = 100;    Delay();
        x = x + 1;    Delay();
        printf( "%s : %d\n", n, x );
        //////////////////////////////////////
        LeaveCriticalSection( &cs );    // cs영역에서 나온다.

        }
        else
        {
            // Critical Section에 들어가지 못할 경우에 할일..
            printf("%s : CriticalSection에 들어 갈수 없습니다.\n", n );
            --i;
        }
    }

    printf( "%s Finish\n", n );
    return 0;
}

int main()
{
    InitializeCriticalSection( &cs );

    HANDLE h1 = CreateThread( 0, 0,    foo, "A", 0, 0 );
    HANDLE h2 = CreateThread( 0, 0,    foo, "\tB", 0, 0 );
    // 64개 까지 대기 가능한 함수.!! - MFC에서 CMultiLock 클래스가 아래 함수의 기능을 클래스화 한다.
    HANDLE h[2] = { h1, h2 };
    WaitForMultipleObjects( 2, h, TRUE, INFINITE );
   
    CloseHandle( h1 );
    CloseHandle( h2 );

    DeleteCriticalSection( &cs );
}

// 예외를 대비하는 새로운 클래스 : MFC 배울때. CSingleLock과 CMultiLock 헷갈리지 마세요.
class CsyncObject
{
public:
    virtual void Lock() {}
    virtual void UnLock() {}
};
class CCriticalSection : public CsyncObject
{
    CRITICAL_SECTION m_cs;
public:
    CCriticalSection()  { InitializeCriticalSection(&m_cs); }
    ~CCriticalSection() { DeleteCriticalSection(&m_cs); }

    void Lock() { EnterCriticalSection(&m_cs); }
    void UnLock() { LeaveCriticalSection(&m_cs); }
};
class CSingleLock
{
    CsyncObject* p;
public:
    CSingleLock( CsyncObject* _p ) : p(_p) {}

    void Lock() { p->Lock(); }
    void UnLock() { p->UnLock(); }
};
CCriticalSection cs;
UINT CALLBACK goo( void* p )
{
    CSingleLock slock(&cs);

    slock.Lock();

    // 그런데.. 여기서 C++ 예외가 발생.
    // 어떻게 될까??
    throw 1;

    slock.UnLock();
}

LONG x = 0;

DWORD CALLBACK foo( void* p )
{
    for ( int i = 0; i < 1000000; ++i )
    {
        // COM 기반 기술에서 자주 사용한다.!!!!!!!
        InterlockedExchange( &x, 0 ); // x = 0
        InterlockedExchangeAdd( &x, 5 );    // x = x+5;
        InterlockedDecrement( &x ); // x -= 1;
        InterlockedIncrement( &x );    // lock inc x 로 구현된 함수. x += 1
        //x = x+1;    // 보장받지 못한다.

        __asm
        {
            //lock inc x // inc 는 원자 연산이다. 즉, inc 실행중 절대 Context Switch가 발생안함.
//            mov eax,    x
//            add eax,    1
//            mov x,        eax
        }
    }
    return 0;
}

int main()
{
    HMODULE hDll = GetModuleHandle( "Kernel32.dll" );
    void* p = (void*)GetProcAddress( hDll, "GetLastError" );
    printf("%p\n", p);
    GetLastError();

    HANDLE h[3];

    h[0] = CreateThread( 0, 0, foo, 0, 0, 0 );
    h[1] = CreateThread( 0, 0, foo, 0, 0, 0 );
    h[2] = CreateThread( 0, 0, foo, 0, 0, 0 );

    WaitForMultipleObjects( 3, h, TRUE, INFINITE );

    CloseHandle( h[0] );
    CloseHandle( h[1] );
    CloseHandle( h[2] );

    printf( "결과 : %d\n", x );
}

// A.cpp 메모리에 변수하나를 올린다.
int main()
{
    char passwd[256] = { 0 };

    printf( "PID : %d\n", GetCurrentProcessId() );
    printf( "passwd 주소 : %p\n", passwd );

    while ( 1 )
    {
        printf( "암호를 입력하세요. >>" );
        scanf( "%s", passwd );
    }
}

// B.cpp  A.exe의 메모리 읽어오기..
int main()
{
    DWORD pid = xxxx;    // A의 PID를 넣으세요.
    char* addr = (char*)0x0012FE60; // passwd의 주소를 넣으세요.

    HANDLE hProcess = OpenProcess( PROCESS_ALL_ACCESS, 0, pid );

    while ( 1 )
    {
        char buf[256] = { 0 };
        DWORD len;
        ReadProcessMemory( hProcess, addr, buf, 256, &len );    // 핵심!!

        printf( "읽어온 data : %s\n", buf );
        getch();
    }
}