《Windows核心编程》第八章——用户模式下的线程同步

下面起了两个线程，每个对一个全局变量加500次，不假思索进行回答，会认为最后这个全局变量的值会是1000，然而事实并不是这样：

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

using namespace std;
typedef unsigned int (_stdcall *PThreadFunc)(void*);
int g_nCount = ;

unsigned int _stdcall ThreadTest1(void*)
{
    for (int i = ; i < ; i++)
    {
        g_nCount++;
    }

    return ;
}

unsigned int _stdcall ThreadTest2(void*)
{
    for (int i = ; i < ; i++)
    {

        g_nCount++;
    }
    return ;
}

void main()
{
   g_nCount = 0;
   HANDLE h1 = (HANDLE)_beginthreadex(NULL, 0, ThreadTest1, NULL, 0, NULL);
   HANDLE h2 = (HANDLE)_beginthreadex(NULL, 0, ThreadTest2, NULL, 0, NULL);
   HANDLE hs[2] = {h1, h2};
   WaitForMultipleObjects(2, hs, TRUE, INFINITE);
   CloseHandle(h1);
   CloseHandle(h2);

　　printf("Global count:%d\n", g_nCount); getchar(); 
}

然而运行多次、每次结果都不同，而且，几乎不会等于1000：

造成这种现象的原因很简单，就是g_nCount在进行自增的时候没有实现原子操作，g_nCount的本质其实是：

• Interlocked函数

为了保证自增的原子性，改为使用Interlocked函数：

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

using namespace std;
typedef unsigned int (_stdcall *PThreadFunc)(void*);
int g_nCount = ;

unsigned int _stdcall ThreadTest1(void*)
{
    for (int i = ; i < ; i++)
    {
        //Sleep(12);
        //g_nCount ++;
        InterlockedIncrement((volatile unsigned long long*)&g_nCount);
    }

    return ;
}

unsigned int _stdcall ThreadTest2(void*)
{
    for (int i = ; i < ; i++)
    {
        //Sleep(10);
        //g_nCount ++;
        InterlockedIncrement((volatile unsigned long long*)&g_nCount);
    }
    return ;
}

void main()
{
    g_nCount = ;
    HANDLE h1 = (HANDLE)_beginthreadex(NULL, , ThreadTest1, NULL, , NULL);
    HANDLE h2 = (HANDLE)_beginthreadex(NULL, , ThreadTest2, NULL, , NULL);
    HANDLE hs[] = { h1, h2 };
    WaitForMultipleObjects(, hs, TRUE, INFINITE);
    CloseHandle(h1);
    CloseHandle(h2);

    printf("Global count:%d\n", g_nCount);
    getchar();
}

这样就保证了自增的原子性。

• 条件变量的使用

#include <iostream>
#include <windows.h>
#include <vector>
#include <process.h>
#include "Queue.h"

using namespace std;
CQueue g_Queue;
SRWLOCK g_srwLock;
CONDITION_VARIABLE g_cvProduce;
CONDITION_VARIABLE g_cvConsume;

int g_nCount = ;
int g_nWriterCount = ;
int g_nReaderCount = ;

unsigned int _stdcall WriterThread(void* pParam)
{
    g_nWriterCount++;
    //printf("Enter writerthread-%d\n", g_nWriterCount);
    while (TRUE)
    {
        Sleep();
        AcquireSRWLockExclusive(&g_srwLock);
        if (g_Queue.IsFull())
        {
            printf("Queue is full..\n");
            SleepConditionVariableSRW(&g_cvProduce, &g_srwLock, INFINITE, );
        }
        /*else
        {

        }*/
        g_Queue.AddElement(g_nCount);
        printf("Produce element:%d\n", g_nCount);
        g_nCount++;
        ReleaseSRWLockExclusive(&g_srwLock);
        WakeConditionVariable(&g_cvConsume);
    }
    return ;
}

unsigned int _stdcall ReaderThread(void* pParam)
{
    g_nReaderCount++;
    //printf("Enter readerthread-%d\n", g_nReaderCount);
    while (TRUE)
    {
        Sleep();
        //这里使用的例子和书中的例子有所不同，书中的例子中的ReaderThread仅仅是读取队列中的内容，而这里

　　　　 //会去修改队列的内容，所以不能使用AcquireSRWLockShared.
        AcquireSRWLockExclusive(&g_srwLock);
        if (g_Queue.IsEmpty())
        {
            printf("Queue is empty..\n");
            SleepConditionVariableSRW(&g_cvConsume, &g_srwLock, INFINITE, );
        }
        /*else
        {

        }*/
        printf("Consume element:%d\n", g_Queue.DelElement());
        ReleaseSRWLockExclusive(&g_srwLock);
        WakeAllConditionVariable(&g_cvProduce);//don't use wakeconditionvariable().
    }
    return ;
}

void main()
{
    InitializeSRWLock(&g_srwLock);
    HANDLE hWriter1 = (HANDLE)_beginthreadex(NULL, , WriterThread, NULL, , NULL);
    HANDLE hWriter2 = (HANDLE)_beginthreadex(NULL, , WriterThread, NULL, , NULL);
    HANDLE hReader1 = (HANDLE)_beginthreadex(NULL, , ReaderThread, NULL, , NULL);
    HANDLE hReader2 = (HANDLE)_beginthreadex(NULL, , ReaderThread, NULL, , NULL);
    HANDLE hReader3 = (HANDLE)_beginthreadex(NULL, , ReaderThread, NULL, , NULL);
    HANDLE hArray[] = { hWriter1, hWriter2, hReader1, hReader2, hReader3 };
    WaitForMultipleObjects(, hArray, TRUE, INFINITE);
    CloseHandle(hWriter1);
    CloseHandle(hWriter2);
    CloseHandle(hReader1);
    CloseHandle(hReader2);
    CloseHandle(hReader3);
    getchar();

}