先来描述一下待解决的问题：

有一个仓库，它最多有七个槽位，最开始每个槽位都是空的。当有空槽位的时候，允许生产者往里面放东西。当槽位上有东西时，允许消费者从里面拿东西；满了则不允许再放，空了则不允许再拿。因为仓库设计问题，同一时间内，只允许一个人进去放东西或者拿东西。需要尽最大的效率安排生产者和消费者的工作。可以看到，这里生产和消费的动作不需要做严格的同步，只要规则允许，可以连续生成三次，也可以连续消费三次。而没有说一定要生产一次，消费一次，再生产一次，再消费一次的顺序来。

// productor_consumer.cpp
// Windows 平台对生产者-消费者问题的解决方案

#include <windows.h>
#include <tchar.h>
#include <list>

// 定义仓库的最大槽位
#define WH_SLOT    7

// 定义等待信号灯的超时时间
#define TIMEOUT    3000

// 定义仓库类
class Warehource
{
public:
    Warehource()
    {
        // 创建一个访问仓库的互斥量，生产者和消费者不能同时访问仓库
        m_hAccess = CreateEvent(NULL, FALSE, TRUE, NULL);
    }
    ~Warehource()
    {
        // 关闭访问互斥量
        CloseHandle(m_hAccess);
    }

    // 放入到仓库
    BOOL put(char ch)
    {
        // 尝试获取互斥量
        if (WAIT_OBJECT_0 == WaitForSingleObject(m_hAccess, 100))
        {
            m_slot.push_back(ch);
            printf("Product an item, now warehourse size is %d\n", m_slot.size());
            SetEvent(m_hAccess); //let's next access available
            return TRUE;
        }
        return FALSE;
    }

    // 从仓库取出
    BOOL get(char* ch)
    {
        // 尝试获取互斥量
        if (WAIT_OBJECT_0 == WaitForSingleObject(m_hAccess, 100))
        {
            *ch = m_slot.front();
            m_slot.pop_front();
            printf("Consume an item, now warehourse size is %d\n", m_slot.size());
            SetEvent(m_hAccess); //let's next access available
            return TRUE;
        }
        return FALSE;
    }
private:
    std::list<char> m_slot;
    HANDLE m_hAccess; //对仓库访问要互斥
};

DWORD WINAPI ProductorRun(LPVOID ud);
DWORD WINAPI ConsumerRun(LPVOID ud);

HANDLE g_hProdExit;            //生产者退出的信号
HANDLE g_hFreeSemaphore;    //仓库空闲槽的信号灯，最大值为WH_SLOT

HANDLE g_hConsExit;            //消费者退出的信号
HANDLE g_hDataSemaphore;    //仓库可用槽的信号灯，最大值为WH_SLOT

int _tmain(int argc, _TCHAR* argv[])
{
    Warehource wh;
    g_hProdExit = CreateEvent(NULL, FALSE, FALSE, NULL);
    g_hConsExit = CreateEvent(NULL, FALSE, FALSE, NULL);
    //仓库空闲槽的信号灯，最大值为WH_SLOT，初始值为WH_SLOT，因为仓库
    //一开始都是空的
    g_hFreeSemaphore = CreateSemaphore(NULL, WH_SLOT, WH_SLOT, NULL);
    //仓库可用槽的信号灯，最大值为WH_SLOT，初始值为0，因为仓库
    //一开始都是空的
    g_hDataSemaphore = CreateSemaphore(NULL, 0, WH_SLOT, NULL);

    // 创建生产者和消费者
    HANDLE hProductor = CreateThread(NULL, NULL, ProductorRun, &wh, 0, 0);
    HANDLE hConsumer  = CreateThread(NULL, NULL, ConsumerRun, &wh, 0, 0);

    // let main thread sleep 30 seconds
    Sleep(3000);

    // 结束生产者
    SetEvent(g_hProdExit);
    WaitForSingleObject(hProductor, INFINITE);
    CloseHandle(g_hProdExit);
    CloseHandle(hProductor);

    // 结束消费者
    SetEvent(g_hConsExit);   
    WaitForSingleObject(hConsumer, INFINITE);
    CloseHandle(g_hConsExit);
    CloseHandle(hConsumer);
    // 关闭信号灯
    CloseHandle(g_hFreeSemaphore);
    CloseHandle(g_hDataSemaphore);
    return 0;
}

DWORD WINAPI ProductorRun(LPVOID ud)
{
    BOOL fDone = FALSE;
    HANDLE h2[] = { g_hProdExit, g_hFreeSemaphore };
    DWORD dwWait = 0;

    Warehource* wh = (Warehource*)ud;
    while (!fDone)
    {
        // 等待退出信号或空闲信号
        dwWait = WaitForMultipleObjects(2, h2, FALSE, TIMEOUT);
        if (dwWait == WAIT_OBJECT_0)
        {
            //退出信号
            fDone = TRUE;
        }
        else if (dwWait == WAIT_OBJECT_0+1)
        {
            // 空闲信号，表示仓库中有空闲槽，尝试放入到仓库
            if (wh->put('a'))
            {                
                // 已经成功放入一个到仓库，则置上一个可用槽的信号灯
                ReleaseSemaphore(g_hDataSemaphore, 1, NULL);
            }
            else //访问仓库超时
            {
                // 将熄灭的空闲槽信号灯置回去
                ReleaseSemaphore(g_hFreeSemaphore, 1, NULL);
            }
        }
    }

    return 0;
}

DWORD WINAPI ConsumerRun(LPVOID ud)
{
    BOOL fDone = FALSE;
    HANDLE h2[] = { g_hConsExit, g_hDataSemaphore };
    DWORD dwWait = 0;

    Warehource* wh = (Warehource*)ud;
    while (!fDone)
    {
        // 等待退出信号或可用信号
        dwWait = WaitForMultipleObjects(2, h2, FALSE, TIMEOUT);
        if (dwWait == WAIT_OBJECT_0)
        {
            //退出信号
            fDone = TRUE;
        }
        else if (dwWait == WAIT_OBJECT_0+1)
        {
            // 可用信号，表示仓库中某个槽已有数据，尝试从中取用
            char ch;
            if (wh->get(&ch))
            {                
                // 已经成功从仓库取出一个，则置上一个空闲槽的信号灯
                ReleaseSemaphore(g_hFreeSemaphore, 1, NULL);
            }
            else //访问仓库超时
            {
                // 将熄灭的可用槽信号灯置回去
                ReleaseSemaphore(g_hDataSemaphore, 1, NULL);
            }
        }
    }
    return 0;
}

注意semaphore是可以让多个线程同时访问共享资源的唯一信号类型。