C++线程同步的方法

线程同步

线程之间通信的两个基本问题是互斥和同步。

线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。

线程互斥是指对于共享的操作系统资源在各线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。
线程互斥是一种特殊的线程同步。实际上，互斥和同步对应着线程间通信发生的两种情况：
1)当有多个线程访问共享资源而不使资源被破坏时；
2)当一个线程需要将某个任务已经完成的情况通知另外一个或多个线程时。

常用的线程同步方法有互斥量(std::mutex)、条件变量(std::condition_variable)、信号量、临界区、事件。
互斥量(std::mutex)和条件变量(std::condition_variable)可以详细看对应的本人简书内容更加详细。

临界区

临界区CRITICAL_SECTION类是windows下用到的，概念和用法与std::mutex类差不多，和std::mutex对应的获取锁权限(lock())、释放锁权限(unlock())对应：
进入临界区

VOID WINAPI EnterCriticalSection(__Inout LPCRITICAL_SECTION lpCriticalSection)

离开临界区

VOID WINAPI LeaveCriticalSection( _Inout_LPCRITICAL_SECTION lpCriticalSection)

不过需要注意的是windows临界区还需要初始化

VOID InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection)

不用时需要释放

VOID WINAPI DeleteCriticalSection(_Inout_ LPCRITICAL_SECTION lpCriticalSection)

信号量

信号允许多个线程同时使用共享资源，他指出了同时访问共享资源的线程最大数目。他允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。在用CreateSemaphore()创建信号量时即要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数配置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就能够发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过ReleaseSemaphore()函数将当前可用资源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。

Windows下信号量：

//头文件
#include <windows.h>

//创建信号量API
HANDLE WINAPI CreateSemaphore(
 _In_opt_ LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,//指向SECURITY_ATTRIBUTES的指针;
 _In_     LONG                  lInitialCount,          //信号量对象的初始值；
 _In_     LONG                  lMaximumCount,  //信号量对象的最大值，这个值必须大于0;
 _In_opt_ LPCTSTR               lpName                 //信号量对象的名称；
);

//等待信号量API
DWORD WINAPI WaitForSingleObject(
  _In_ HANDLE hHandle,          //信号量对象句柄
  _In_ DWORD  dwMilliseconds    //等待信号量时间，INFINET代表永久等待；
);
返回值：
WAIT_ABANDONED(0x00000080L) 表示拥有信号量的线程再终止前未释放该信号量；
WAIT_OBJECT_0(0x00000000L)  表示等到了信号量；
WAIT_TIMEOUT(0x00000102L)   表示等待超时；
WAIT_FAILED((DWORD)0xFFFFFFFF)  表示该函数执行失败，用GetLastError()得到错误码；  

//释放信号量句柄
BOOL WINAPI ReleaseSemaphore(
  _In_      HANDLE hSemaphore,         //信号量对象句柄；
  _In_      LONG   lReleaseCount,      //信号量释放的值，必须大于0；
  _Out_opt_ LPLONG lpPreviousCount     //前一次信号量值的指针，不需要可置为空；
);
返回值：成功返回非0；

#include <iostream>
#include <windows.h>
using namespace std;

HANDLE g_hSemaphore = NULL;                             //声明信号量变量

unsigned long WINAPI Fun(LPVOID lpParamter)
{
    int iRunTime = 0;
    //执行100次跳出
    while (++iRunTime < 100)
    {
        WaitForSingleObject(g_hSemaphore, INFINITE);      //信号量值-1
        cout << "Fun() is running!" << endl;
        ReleaseSemaphore(g_hSemaphore, 1, NULL);          //信号量值+1
        Sleep(10);
    }
    ExitThread(-1);
}

int main()
{
    //创建信号量对象
    g_hSemaphore = CreateSemaphore(NULL          //信号量的安全特性
        , 1            //设置信号量的初始计数。可设置零到最大值之间的一个值
        , 1            //设置信号量的最大计数
        , NULL         //指定信号量对象的名称
    );
    if (NULL == g_hSemaphore)
    {
        cout << "create hSemaphore failed! error_code:" << GetLastError() << endl;
        return 0;
    }

    int iRunTime = 0;
    unsigned long ulThreadId = 0;
    //创建一个子线程
    HANDLE hThread = CreateThread(NULL, 0, Fun, NULL, 0, &ulThreadId);

    //执行100次跳出
    while (++iRunTime < 100)
    {
        WaitForSingleObject(g_hSemaphore, INFINITE);   //信号量值-1
        cout << "main() is running, Thread id is " << ulThreadId << endl;
        ReleaseSemaphore(g_hSemaphore, 1, NULL);       //信号量值+1
        Sleep(10);
    }
    system("pause");
    return 0;
}

Linux下信号量：

int sem_init(sem_t *sem, int pshared, unsigned int value); 
1)pshared==0 用于同一多线程的同步； 
2)若pshared>0 用于多个相关进程间的同步(即由fork产生的)； 
int sem_getvalue(sem_t *sem, int *sval); 
取回信号量sem的当前值，把该值保存到sval中。 
若有1个或更多的线程或进程调用sem_wait阻塞在该信号量上，该函数返回两种值： 
1) 返回0 
2) 返回阻塞在该信号量上的进程或线程数目 
linux采用返回的第一种策略。 
sem_wait(或sem_trywait)相当于P操作，即申请资源。 
int sem_wait(sem_t *sem); // 这是一个阻塞的函数 
测试所指定信号量的值,它的操作是原子的。 
若sem>0，那么它减1并立即返回。 
若sem==0，则睡眠直到sem>0，此时立即减1，然后返回； 
int sem_trywait(sem_t *sem); // 非阻塞的函数 
其他的行为和sem_wait一样，除了： 
若sem==0，不是睡眠，而是返回一个错误EAGAIN。 
sem_post相当于V操作，释放资源。 
int sem_post(sem_t *sem); 
把指定的信号量sem的值加1; 
呼醒正在等待该信号量的任意线程。

#include <iostream>
#include <pthread.h>
#include <semaphore.h>
using namespace std;

static sem_t g_semaphore;
static const int g_iRunTime = 5000;

void* Fun(void* ptr)
{
   int iRunTime = 0;
   while(++iRunTime< g_iRunTime)
   {
      sem_wait(&g_semaphore);
      cout<< "Fun() is running!" << endl;
      sem_post(&g_semaphore);
      usleep(100);
    }
}

int main()
{
   pthread_t hHandle;
   sem_init(&g_semaphore, 0, 1);
   int iRet = pthread_create(&hHandle, NULL, Fun, NULL);        //create a thread;
   if(0 != iRet)
   {
       cout << "Create thread failed!" << endl;
   }
   sleep(1);
   int iRunTime = 0;
   while(++iRunTime<g_iRunTime)
   {
      sem_wait(&g_semaphore);
      cout << "main is running!" << endl;
      sem_post(&g_semaphore);
      usleep(100);
   }
   pthread_join(hHandle, NULL);
   return 0;
}

事件

事件对象也能够通过通知操作的方式来保持线程的同步。并且能够实现不同进程中的线程同步操作，这个跟信号量用起来有点像。

#include "iostream"    
#include "windows.h"    
using namespace std;    
    
DWORD WINAPI ThreadProc1(LPVOID lpParam);    
DWORD WINAPI ThreadProc2(LPVOID lpParam);    
HANDLE hEvent = NULL;    
HANDLE hThread1 = NULL;    
HANDLE hThread2 = NULL;    
int main(int argc, char *args[])    
{    
    hEvent = CreateEvent(NULL, TRUE, TRUE, NULL)</span>; //使用手动重置为无信号状态，初始化时有信号状态    
    //hEvent = CreateEvent(NULL, FALSE, TRUE, NULL); //当一个等待线程被释放时，自动重置为无信号状态，初始是有信号状态    
    //if (SetEvent(hEvent))    
    //{    
    //  cout << "setEvent 成功" <<endl;    
    //}    
    hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc1, NULL, 0,NULL);    
    Sleep(200);    
    hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadProc2, NULL, 0,NULL);    
    Sleep(200);    
    if ( NULL == hThread1)    
    {    
        cout <<"create thread fail!";    
    }    
    //DWORD dCount = ResumeThread(hThread);    
    //cout << LOWORD(dCount) << endl;    
    return 0;    
}    
DWORD WINAPI ThreadProc1(LPVOID lpParam)    
{    
    cout <<"in thread1@!"<<endl;    
        
    DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);    
        
    if ( WAIT_OBJECT_0 == dReturn)    
    {    
        cout <<" thread1 signaled ! "<<endl;    
    }    
    cout <<"in thread1 --signal"<<endl;    
        
    //SetEvent(hEvent);    
    return 0;    
}    
DWORD WINAPI ThreadProc2(LPVOID lpParam)    
{    
    cout <<"in thread2@!"<<endl;    
        
    DWORD dReturn = WaitForSingleObject(hEvent,INFINITE);    
        
    if ( WAIT_OBJECT_0 == dReturn)    
    {    
        cout <<"thread2 signaled ! "<<endl;    
    }    
    cout <<"in thread2--signal"<<endl;    
        
    return 0;    
}

参考文章linux c 线程间同步(通信)的几种方法--互斥锁，条件变量，信号量，读写锁Linux下线程同步的几种方法C++中四种线程同步的方法