用内核对象进行线程同步——信号量内核对象

信号量内核对象包含一个使用计数，还有另外俩个32位值：一个最大资源计数，一个当前资源计数。
最大资源计数表示信号量可以控制的最大资源数量，即可以同时调度的最大线程数；当前资源计数表示信号量当前可用资源的数量，即当前可调度的线程数。

信号量规则：
1. 当前资源计数 > 0, 信号量处于触发状态
2. 当前资源计数 = 0, 信号量处于未触发状态
3. 系统绝不会让当前资源计数 < 0
4. 系统绝不会让当前资源计数 > 最大资源计数

创建信号量内核对象

HANDLE CreateSemaphore(
     LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
     LONG lInitialCount,  // 当前资源计数
     LONG lMaximumCount,  // 最大资源计数
     LPCSTR lpName
    );

打开信号量内核对象

HANDLE OpenSemaphore(
     DWORD dwDesiredAccess,
     BOOL bInheritHandle,
     LPCSTR lpName
    );

递增信号量内核对象

BOOL ReleaseSemaphore(
     HANDLE hSemaphore,
     LONG lReleaseCount, // lReleaseCount + 当前资源计数 = 新的当前资源计数
     LPLONG lpPreviousCount
    );

案例1

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

using namespace std;

HANDLE h_Semaphore;
long* pLong = NULL;

UINT WINAPI ThreadFunc1(PVOID pArguments)
{
    // 等待函数如果发现信号量的当前资源计数为0（信号量处于未触发状态），则线程进入等待状态
    // 如果信号量的当前资源计数不为0（信号量处于触发状态），当前资源计数减1，线程进入可调度状态
    WaitForSingleObject(h_Semaphore, INFINITE);
    Sleep(10000);
    cout << "ThreadFunc1.." << endl;
    // 结束对资源的访问后，调用ReleaseSemaphore对当前资源计数加1
    ReleaseSemaphore(h_Semaphore, 1, pLong);
    _endthreadex(0);
    return 0;
}

UINT WINAPI ThreadFunc2(PVOID pArguments)
{
    WaitForSingleObject(h_Semaphore, INFINITE);
    Sleep(10000);
    cout << "ThreadFunc2.." << endl;
    ReleaseSemaphore(h_Semaphore, 1, pLong);
    _endthreadex(0);
    return 0;
}

UINT WINAPI ThreadFunc3(PVOID pArguments)
{
    WaitForSingleObject(h_Semaphore, INFINITE);
    Sleep(10000);
    cout << "ThreadFunc3.." << endl;
    ReleaseSemaphore(h_Semaphore, 1, pLong);
    _endthreadex(0);
    return 0;
}
UINT WINAPI ThreadFunc4(PVOID pArguments)
{
    WaitForSingleObject(h_Semaphore, INFINITE);
    int n = 0;
    Sleep(10000);
    cout << "ThreadFunc4.." << endl;
    ReleaseSemaphore(h_Semaphore, 1, pLong);
    _endthreadex(0);
    return 0;
}
UINT WINAPI ThreadFunc5(PVOID pArguments)
{
    WaitForSingleObject(h_Semaphore, INFINITE);
    Sleep(10000);
    cout << "ThreadFunc5.." << endl;
    ReleaseSemaphore(h_Semaphore, 1, pLong);
    _endthreadex(0);
    return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
    HANDLE   handle[5];
    unsigned    unThreadID[5];

    // 创建一个信号量
    // 当前资源计数器被初始化为0，信号量没有被触发
    // 最大资源计数为3
    h_Semaphore = CreateSemaphore(NULL, 0, 5, NULL);
    handle[0] = (HANDLE)_beginthreadex(NULL,
        0,
        &ThreadFunc1,
        NULL,
        0,
        &unThreadID[0]);
    handle[1] = (HANDLE)_beginthreadex(NULL,
        0,
        &ThreadFunc2,
        NULL,
        0,
        &unThreadID[1]);
    handle[2] = (HANDLE)_beginthreadex(NULL,
        0,
        &ThreadFunc3,
        NULL,
        0,
        &unThreadID[2]);
    handle[3] = (HANDLE)_beginthreadex(NULL,
        0,
        &ThreadFunc4,
        NULL,
        0,
        &unThreadID[3]);
    handle[4] = (HANDLE)_beginthreadex(NULL,
        0,
        &ThreadFunc5,
        NULL,
        0,
        &unThreadID[4]);

    // 递增信号量的当前资源计数为5（0+5=5）
    // 当前资源计数大于0时，触发了信号量，此时可以同时调度2个等待该信号量的线程，其余线程继续等待
    ReleaseSemaphore(h_Semaphore, 5, NULL);
    getchar();
    CloseHandle(h_Semaphore);
    return 0;
}

案例2

// ThreadDemo.cpp : コンソール アプリケーションのエントリ ポイントを定義します。
//

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

using namespace std;

HANDLE h_Semaphore;
long* pLong = NULL;
int g_Data[10] = { 0 };

UINT WINAPI ThreadFunc(PVOID pArguments)
{
    WaitForSingleObject(h_Semaphore, INFINITE);
    WaitForSingleObject(h_Semaphore, INFINITE);
    WaitForSingleObject(h_Semaphore, INFINITE);
    _endthreadex(0);
    return 0;
}


int _tmain(int argc, _TCHAR* argv[])
{
    HANDLE   handle;
    unsigned    unThreadID;
    int i = 0;
    // 创建一个信号量
    // 当前资源计数器被初始化为0，信号量没有被触发
    // 最大资源计数为5
    h_Semaphore = CreateSemaphore(NULL, 0, 5, NULL);
    // 调用ReleaseSemaphore使当前资源计数器加1，当当前资源计数器<=5时，ReleaseSemaphore返回成功
    // 当while循环结束时，当前资源计数=5，g_Data[0]/g_Data[1]/g_Data[2]/g_Data[3]/g_Data[4]赋值
    while (TRUE)
    {
        if (ReleaseSemaphore(h_Semaphore, 1, NULL))
        {
            g_Data[i] = i + 10;
            i++;
        }
        else
        {
            cout << "ReleaseSemaphore error" << endl;
            break;
        }
    }
    for (int i = 0; i < 10; i++)
    {
        cout << g_Data[i] << endl;
    }
    // 在线程中调用信号量的等待函数WaitForSingleObject三次，则当前资源计数器减3
    // 此时当前资源计数=2
    handle = (HANDLE)_beginthreadex(NULL,
        0,
        &ThreadFunc,
        NULL,
        0,
        &unThreadID);

    WaitForSingleObject(handle, INFINITE);
    // 当前资源计数=2,则还可以调用ReleaseSemaphore3次
    // g_Data[5]/g_Data[6]/g_Data[7]赋值
    while (TRUE)
    {
        if (ReleaseSemaphore(h_Semaphore, 1, NULL))
        {
            g_Data[i] = i + 10;
            i++;
        }
        else
        {
            cout << "ReleaseSemaphore error" << endl;
            break;
        }
    }
    for (int i = 0; i < 10; i++)
    {
        cout << g_Data[i] << endl;
    }

    getchar();
    CloseHandle(h_Semaphore);
    return 0;
}

最后输出结果为：
ReleaseSemaphore error
10
11
12
13
14
0
0
0
0
0
ReleaseSemaphore error
10
11
12
13
14
15
16
17
0
0