C++线程同步总结

/*know it before
//unsigned long _beginthreadex( void *security, unsigned stack_size, unsigned ( __stdcall *start_address )( void * ), void *arglist, unsigned initflag, unsigned *thrdaddr );
//第1个参数：安全属性，NULL为默认安全属性 
//第2个参数：指定线程堆栈的大小。如果为0，则线程堆栈大小和创建它的线程的相同。一般用0 
//第3个参数：指定线程函数的地址，也就是线程调用执行的函数地址(用函数名称即可，函数名称就表示地址) 
//第4个参数：传递给线程的参数的指针，可以通过传入对象的指针，在线程函数中再转化为对应类的指针 
//第5个参数：线程初始状态，0:立即运行；CREATE_SUSPEND：suspended（悬挂） 
//第6个参数：用于记录线程ID的地址
//如果你的编程只调用 Win32 API/SDK ，就放心用 CreateThread；如果要用到
//C++ 运行时间库，那么就要使用 _beginthreadex ，并且需要在编译环境中选择 Use MultiThread Lib/DLL
//绝对不要调用系统自带的CreateThread函数创建新的线程，而应该使用_beginthreadex，除非你在线程中绝不使用需要tiddata结构的运行时库函数

//WaitForMultipleObjects(threadNum, hThread, TRUE, INFINITE);   
//threadNum 句柄的数量 最大值为MAXIMUM_WAIT_OBJECTS（64） 
//hThread 句柄数组的指针 HANDLE 类型可以为（Event，Mutex，Process，Thread，Semaphore ）数组 
//BOOL bWaitAll 等待的类型，如果为TRUE 则等待所有信号量有效在往下执行，FALSE 当有其中一个信号量有效时就向下执行  
//DWORD dwMilliseconds 超时时间 超时后向执行。 如果为WSA_INFINITE 永不超时。如果没有信号量就会在这死等。

//CloseHandle(hThread[i]);
//只是关闭了一个线程句柄对象，表示我不再使用该句柄，即不对这个句柄对应的线程做任何干预了,放弃控制权。并没有结束线程。
*/

//用Interlocked系列函数实现线程同步实例如下：
//旋转锁 当然这种方法会浪费ｃｐｕ时间，因为ｃｐｕ要不断地执行InterlockedExchange()函数，单CPU不推荐这种方法。
#include <iostream> 
using namespace std;  
#include <process.h>
#include <windows.h> 
const int threadNum=10;
HANDLE hThread[threadNum];
volatile unsigned int ISOK=0;
unsigned int _stdcall Interlocked(PVOID threadId)
{ 
    while(InterlockedExchange(&ISOK,1)==1) ; 
    cout<<"线程："<<*(int*)threadId<<"开始"<<endl; 
    Sleep(100);
    cout<<"线程："<<*(int*)threadId<<"结束"<<endl; 
    InterlockedExchange(&ISOK,0);  
    return 0;
}

void InterlockedTest()
{
    int threadId[threadNum];
    for(int i=0;i<threadNum;i++)
    {
        threadId[i]=i+1;
    }
    cout<<"1：用Interlocked系列函数实现线程同步"<<endl;
    for(int i=0;i<threadNum;i++){ 
        hThread[i]=(HANDLE)_beginthreadex(NULL, 0, Interlocked,threadId+i, 0, NULL); 
    }
    WaitForMultipleObjects(threadNum, hThread, TRUE, INFINITE);   
    for(int i=0;i<threadNum;i++)
    {
        CloseHandle(hThread[i]);
    } 
}

//用CRITICAL_SECTION及其系列函数实现线程同步实例如下：
//关键段 
// #include <iostream> 
// using namespace std;  
// #include <process.h>
// #include <windows.h> 
// const int threadNum=10;
// HANDLE hThread[threadNum]; 
CRITICAL_SECTION g_cs;//构造一个CRITICAL_SECTION实例
unsigned int _stdcall  CriticalSection(PVOID threadId)
{ 
    EnterCriticalSection(&g_cs);//进入关键段
    cout<<"线程："<<*(int*)threadId<<"开始"<<endl; 
    Sleep(100);
    cout<<"线程："<<*(int*)threadId<<"结束"<<endl; 
    LeaveCriticalSection(&g_cs);//进入关键段 
    return 0;
}


void CriticalSectionTest()
{
    int threadId[threadNum];
    for(int i=0;i<threadNum;i++)
    {
        threadId[i]=i+1;
    }
    InitializeCriticalSection(&g_cs);//初始化g_cs的成员 
    cout<<"2：用CRITICAL_SECTION及其系列函数实现线程同步"<<endl;
    for(int i=0;i<10;i++){ 
        hThread[i]=(HANDLE)_beginthreadex(NULL, 0, CriticalSection,threadId+i, 0, NULL);  
    }
    WaitForMultipleObjects(threadNum, hThread, TRUE, INFINITE);   
    for(int i=0;i<threadNum;i++)
    {
        CloseHandle(hThread[i]);
    } 
    DeleteCriticalSection(&g_cs);//删除关键段
}

/*
SRWLock的目的和关键段是一样的，就是对资源的保护，不让其他线程访问。
不同的是，它区分线程是读线程还是写线程。
我们都是知道，一个资源可以同时被多个线程同时读，就是不能同时读，或是读写。
也是是说写必须是独占的方式，而读可以以共享的方式访问，如果以共享的方式访问肯定就比CRITICAL_SECTION性能好。
*/
//用RTL_SRWLOCK及其系列函数实现线程同步实例如下：
//读写锁 
RTL_SRWLOCK  lock;//构造一个RTL_SRWLOCK实例
unsigned int _stdcall  SrwLock(PVOID threadId)
{ 
    AcquireSRWLockExclusive(&lock);//进入读写锁
    cout<<"线程："<<*(int*)threadId<<"开始"<<endl; 
    Sleep(100);
    cout<<"线程："<<*(int*)threadId<<"结束"<<endl; 
    ReleaseSRWLockExclusive(&lock);//进入读写锁
    return 0;
}

void SrwLockTest()
{
    int threadId[threadNum];
    for(int i=0;i<threadNum;i++)
    {
        threadId[i]=i+1;
    }
    InitializeSRWLock(&lock);//初始化lock的成员 
    cout<<"3：用RTL_SRWLOCK及其系列函数实现线程同步"<<endl;
    for(int i=0;i<10;i++){ 
        hThread[i]=(HANDLE)_beginthreadex(NULL, 0, SrwLock,threadId+i, 0, NULL);  
    }
    WaitForMultipleObjects(threadNum, hThread, TRUE, INFINITE);   
    for(int i=0;i<threadNum;i++)
    {
        CloseHandle(hThread[i]);
    } 

}
//用事件内核对象实现线程同步实例如下：
//事件
HANDLE event1; 

unsigned int _stdcall  Event(PVOID threadId)
{
    WaitForSingleObject(event1,INFINITE);
    int* p=(int*)threadId;
    cout<<"线程："<<*p<<"开始"<<endl; 
    Sleep(100);
    cout<<"线程："<<*p<<"结束"<<endl;  
    SetEvent(event1);
    return 1;
}

void EventTest()
{
    int threadId[threadNum];
    for(int i=0;i<threadNum;i++)
    {
        threadId[i]=i+1;
    }
    event1=CreateEvent(NULL,false,true,NULL); 
    cout<<"4：用事件内核对象实现线程同步"<<endl;     
    for(int i=0;i<threadNum;i++)
    {
        hThread[i] =(HANDLE)_beginthreadex(NULL, 0, Event ,threadId+i, 0, NULL);  
    }
    WaitForMultipleObjects(threadNum, hThread, TRUE, INFINITE);  
    for(int i=0;i<threadNum;i++)
    {
        CloseHandle(hThread[i]);
    } 
    CloseHandle(event1);
}

//用信号量内核对象实现线程同步实例如下：
//信号量
HANDLE semaphore; 
unsigned int _stdcall  Semaphore(PVOID threadId)
{
    WaitForSingleObject(semaphore, INFINITE);  
    cout<<"线程："<<*(int*)threadId<<"开始"<<endl; 
    Sleep(100);
    cout<<"线程："<<*(int*)threadId<<"结束"<<endl; 
    ReleaseSemaphore(semaphore,1,NULL); 
    return 0;
}

void SemaphoreTest()
{
    int threadId[threadNum];
    for(int i=0;i<threadNum;i++)
    {
        threadId[i]=i+1;
    }
    semaphore=CreateSemaphore(NULL,1,1,NULL);
    cout<<"5：用信号量内核对象实现线程同步"<<endl;
    for(int i=0;i<10;i++){ 
        hThread[i]=(HANDLE)_beginthreadex(NULL, 0, Semaphore,threadId+i, 0, NULL);  
    }
    WaitForMultipleObjects(threadNum, hThread, TRUE, INFINITE);   
    for(int i=0;i<threadNum;i++)
    {
        CloseHandle(hThread[i]);
    }
    CloseHandle(semaphore);
}
void main()
{
    InterlockedTest();
    CriticalSectionTest();
    SrwLockTest();
    EventTest();
    SemaphoreTest();
}