windows下线程同步

windows下线程同步

windows下的一些同步方法，volatile、Interlocke函数、CRITICAL_SECTION、SRWLOCK、Mutex。

• volatile：
  变量声明为 volatile 变量，对于仅有一个线程写，其余线程读的变量，是安全的，如：

volatile int num = 0;

• Interlocked函数：
  该系列函数能实现原子操作：

LONG __cdecl InterlockedIncrement(_Inout_ LONG volatile *Addend);
LONG __cdecl InterlockedDecrement(_Inout_ LONG volatile *Addend);
LONG __cdecl InterlockedExchange(_Inout_ LONG volatile *Target,_In_ LONG Value);
LONG __cdecl InterlockedExchangeAdd(_Inout_ LONG volatile *Addend,_In_ LONG Value);
PVOID __cdecl InterlockedExchangePointer(_Inout_ PVOID volatile *Target,_In_ PVOID Value);
等.

• CRITICAL_SECTION：
  操作函数：

//临界区初始化
void WINAPI InitializeCriticalSection(_Out_ LPCRITICAL_SECTION lpCriticalSection);
//初始化临界区和自旋锁次数，临界区无法进入时会循环一定次数，如果还是无法进入则线程睡眠
BOOL WINAPI InitializeCriticalSectionAndSpinCount(_Out_ LPCRITICAL_SECTION lpCriticalSection,_In_ DWORD dwSpinCount);
//进入临界区，如果无法进入则线程睡眠
void WINAPI EnterCriticalSection(_Inout_ LPCRITICAL_SECTION lpCriticalSection);
//进入临界区，如果无法进入，则立即返回FALSE，不会进入睡眠
BOOL WINAPI TryEnterCriticalSection(_Inout_ LPCRITICAL_SECTION lpCriticalSection);
//离开临界区，在 return 之前离开
void WINAPI LeaveCriticalSection(_Inout_ LPCRITICAL_SECTION lpCriticalSection);
//释放临界区资源
void WINAPI DeleteCriticalSection(_Inout_ LPCRITICAL_SECTION lpCriticalSection);

• SRWLOCK读写锁：
  操作函数：

//初始化
VOID WINAPI InitializeSRWLock(_Out_ PSRWLOCK SRWLock);
//独占进入，用于写
VOID WINAPI AcquireSRWLockExclusive(_Inout_ PSRWLOCK SRWLock);
//释放独占锁
VOID WINAPI ReleaseSRWLockExclusive(_Inout_ PSRWLOCK SRWLock);
//共享进入，用于读
VOID WINAPI AcquireSRWLockShared(_Inout_ PSRWLOCK SRWLock);
//释放共享锁
VOID WINAPI ReleaseSRWLockShared(_Inout_ PSRWLOCK SRWLock);
//尝试进入独占锁，进入失败则立即返回FALSE，线程不会进入睡眠，进入成功返回TRUE并拥有锁
BOOLEAN WINAPI TryAcquireSRWLockExclusive(_Inout_ PSRWLOCK SRWLock);
//尝试进入共享锁，进入失败则立即返回FALSE，线程不会进入睡眠，进入成功返回TRUE并拥有锁
BOOLEAN WINAPI TryAcquireSRWLockShared(_Inout_ PSRWLOCK SRWLock);
//使用条件变量唤醒锁
BOOL WINAPI SleepConditionVariableSRW(_Inout_ PCONDITION_VARIABLE ConditionVariable,_Inout_ PSRWLOCK SRWLock,_In_ DWORD dwMilliseconds,_In_ ULONG Flags);

• Mutex：
  操作函数：

//创建mutex
HANDLE WINAPI CreateMutex(_In_opt_ LPSECURITY_ATTRIBUTES lpMutexAttributes,_In_ BOOL bInitialOwner,_In_opt_ LPCTSTR lpName);
//等待
DWORD WINAPI WaitForSingleObject(_In_ HANDLE hHandle,_In_ DWORD  dwMilliseconds);
//释放
BOOL WINAPI ReleaseMutex(_In_ HANDLE hMutex);

代码：

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

typedef void (*OPFunc)();

CRITICAL_SECTION        g_cs;
SRWLOCK                 g_SRWlock;
volatile LONG           gv_num = 0;
LONG                    g_num = 0;
HANDLE                  g_hMutex;
const static ULONG      gcs_count = 1000000;

void FuncVolatileRead()
{
    auto iRead = gv_num;
}

void FuncVolatileWrite()
{
    gv_num = 1;
}

void FuncInterlock()
{
    InterlockedAdd(&g_num, 2); 
}

void FuncCriticalSection()
{
    EnterCriticalSection(&g_cs);
    ++g_num;
    LeaveCriticalSection(&g_cs);
}

void FuncSRWLockRead()
{
    AcquireSRWLockShared(&g_SRWlock);
    auto iRead = g_num;
    ReleaseSRWLockShared(&g_SRWlock);
}

void FuncSRWLockWrite()
{
    AcquireSRWLockExclusive(&g_SRWlock);
    g_num = 1;
    ReleaseSRWLockExclusive(&g_SRWlock);
}

void FuncMutex()
{
    WaitForSingleObject(g_hMutex, INFINITE);
    g_num = 0;
    ReleaseMutex(g_hMutex);
}

DWORD WINAPI LoopFunc(PVOID param)
{
    auto opFunc = (OPFunc)param;
    for (int i = 0; i < gcs_count; ++i)
        opFunc();
    return 0;
}

void WaitFuncComplete(const int threadNum , OPFunc opFunc)
{
    std::cout << "threadNum: " << threadNum << " time: ";
    HANDLE * phThread = new HANDLE[threadNum];
    for(int i = 0;i < threadNum;++i)
    {
        phThread[i] = CreateThread(NULL,0,LoopFunc,opFunc,0,NULL);
    }

    LARGE_INTEGER freq,start,end;   //计时
    QueryPerformanceFrequency(&freq);
    QueryPerformanceCounter(&start);
    WaitForMultipleObjects(threadNum,phThread,TRUE,INFINITE);
    QueryPerformanceCounter(&end);
    LONGLONG time = ((end.QuadPart - start.QuadPart) * 1000) / freq.QuadPart;
    std::cout << std::setw(6) << time << "ms" << std::endl;

    for(int i = 0;i < threadNum;++i)
        CloseHandle(phThread[i]);
    delete phThread;
    phThread = NULL;
}

int main()
{
    InitializeCriticalSectionAndSpinCount(&g_cs,4000);
    InitializeSRWLock(&g_SRWlock);
    g_hMutex = CreateMutex(NULL,FALSE,NULL);
    for (int i = 1; i < 17; i *= 2)
    {
        std::cout << std::left << std::setw(16) << "Volatile Read ";
        WaitFuncComplete(i,FuncVolatileRead);
        std::cout << std::setw(16) << "Volatile Write ";
        WaitFuncComplete(i,FuncVolatileWrite);
        std::cout << std::setw(16) << "Interlock ";
        WaitFuncComplete(i,FuncInterlock);
        std::cout << std::setw(16) << "CriticalSection ";
        WaitFuncComplete(i,FuncCriticalSection);
        std::cout << std::setw(16) << "SRWLock Read ";
        WaitFuncComplete(i,FuncSRWLockRead);
        std::cout << std::setw(16) << "SRWLock Write ";
        WaitFuncComplete(i,FuncSRWLockWrite);
        std::cout << std::setw(16) << "Mutex ";
        WaitFuncComplete(i,FuncMutex);
        std::cout << std::endl;
    }
    DeleteCriticalSection(&g_cs);
    CloseHandle(g_hMutex);
    getchar();
    return 0;
}

计时函数：

    LARGE_INTEGER freq,start,end;   //计时
    QueryPerformanceFrequency(&freq);
    QueryPerformanceCounter(&start);
    WaitForMultipleObjects(threadNum,phThread,TRUE,INFINITE);
    QueryPerformanceCounter(&end);
    LONGLONG time = ((end.QuadPart - start.QuadPart) * 1000) / freq.QuadPart;
    std::cout << std::setw(6) << time << "ms" << std::endl;

效果：
Debug版本：

Release版本：

小结：
volatile 在所有方法中是最快的，volatile 写可能会引起 CPU 维护高速缓存之间的一致性，会比读取耗时多一些；SRWLOCK 比 CRITICAL_SECTION 效果能好一些，特别是在线程数量较多的时候；Mutex 会在用户态和内核态之间切换，导致性能下降；release版本比debug版本快得多。

代码链接：
http://download.csdn.net/detail/yangyang031213/9904036
https://github.com/yangyang0312/cpp/tree/master/windows/ThreadSync