#include <iostream>
#include <process.h>
#include <windows.h>

long g_count = 0;
long g_sum   = 0;
static const int g_s_Count = 10;
CRITICAL_SECTION g_csThreadParamer;
CRITICAL_SECTION g_csThreadCode;
HANDLE          g_threadEvent;
HANDLE          g_threadMutex;

unsigned int WINAPI ThreadFunc(void *p) {
    int nThreadNum = *(int *)p;

    ReleaseMutex(g_threadMutex);

    Sleep(1000);

    EnterCriticalSection(&g_csThreadCode);
    g_count++;
    printf("线程编号: %d, 全局资源值为: %d\n", nThreadNum, g_count);
    LeaveCriticalSection(&g_csThreadCode);
    
    return 0;
}

int main(void) {
    std::cout << "Create the Thread" << std::endl;

    g_threadMutex = CreateMutex(NULL, FALSE, NULL);

    //g_threadEvent = CreateEvent(   NULL,
    //                            FALSE,
    //                            FALSE,
    //                            NULL);
    InitializeCriticalSection(&g_csThreadCode);

    HANDLE threadHandle[g_s_Count];

    for(int i = 0; i < g_s_Count; ) {
        
        threadHandle[i] = (HANDLE)_beginthreadex(NULL,
                                            0,
                                            ThreadFunc,
                                            &i,
                                            0,
                                            NULL);
        WaitForSingleObject(g_threadMutex, INFINITE); 
        
        ++i;
    }

    WaitForMultipleObjects(g_s_Count, threadHandle, true, INFINITE);

    for(int i = 0; i < g_s_Count; ++i) {
        CloseHandle(threadHandle[i]);
    }
    DeleteCriticalSection(&g_csThreadCode);
    std::cout << "Thread Ending" << std::endl; 

    return 0;
}


注：它与CS一样，不能进行同步，都有线程拥有权。但是可以进行多进程线程同步。

如下例子：

线程一：

#include <iostream>
#include <conio.h>
#include <windows.h>

int main() {
    HANDLE hMutex = CreateMutex(NULL, TRUE, TEXT("Mutex_MoreWindows"));
    printf("互斥量已经创建，现在按任意键触发互斥量\n"); 
    getch();

    ReleaseMutex(hMutex);
    return 0;
};



线程二： 

int main(void) {
    g_threadMutex = OpenMutex(MUTEX_ALL_ACCESS, TRUE, TEXT("Mutex_MoreWindows"));

    if(g_threadMutex == NULL) {
        std::cout << "open fail" << std::endl;
        return 0;
    }

    DWORD dResult = WaitForSingleObject(g_threadMutex, 10 * 1000);
    switch (dResult)  
    {  
    case WAIT_ABANDONED:  
        printf("拥有互斥量的进程意外终止\n");  
        break;  
  
    case WAIT_OBJECT_0:  
        printf("已经收到信号\n");  
        break;  
  
    case WAIT_TIMEOUT:  
        printf("信号未在规定的时间内送到\n");  
        break;  
    }  
    CloseHandle(g_threadMutex);  
    return 0;
}



通过关掉进行或者正常结束进行都能很好的进行多进程中的线程同步。