Linux平台用C++实现信号量，同步线程

我会带着你远行 2022-06-09 02:19 391阅读 0赞

使用Linux平台上现有的信号量sem\_t相关的一组API，可以方便地进行线程同步。现在用pthread\_mutex\_t和pthread\_cond\_t相关的一组API实现信号量机制。这组API包括：pthread\_mutex\_init，pthread\_cond\_init，pthread\_mutex\_lock，pthread\_cond\_signal，pthread\_mutex\_unlock，pthread\_cond\_wait，pthread\_cond\_timedwait，pthread\_cond\_destroy和pthread\_mutex\_destroy，可以在[linux][].com">http://www.9[linux][linux 1].com找到各API的说明。下边，是封装的信号量类，以及[测试][Link 1]代码。使用VS2005编辑，在虚拟机 Fedora 13中编译，[测试][Link 1]通过。  
MySemaphore.h  
view plain  
\#ifndef Semaphore\_Header  
\#define Semaphore\_Header

\#include <iostream>  
\#include <pthread.h>  
\#include <errno.h>  
\#include <assert.h>

using namespace std;

//------------------------------------------------------------------------

class CSemaphoreImpl  
\{  
protected:  
CSemaphoreImpl(int n, int max);  
~CSemaphoreImpl();  
void SetImpl();  
void WaitImpl();  
bool WaitImpl(long lMilliseconds);

private:  
volatile int m\_n;  
int m\_max;  
pthread\_mutex\_t m\_mutex;  
pthread\_cond\_t m\_cond;  
\};

inline void CSemaphoreImpl::SetImpl()  
\{  
if (pthread\_mutex\_lock(&m\_mutex))  
cout<<"cannot signal semaphore (lock)"<<endl;  
if (m\_n < m\_max)  
\{  
\++m\_n;  
\}  
else  
\{  
pthread\_mutex\_unlock(&m\_mutex);  
cout<<"cannot signal semaphore: count would exceed maximum"<<" m\_n = "<<m\_n<<"m\_max = "<<m\_max<<endl;  
\}  
//重新开始等待m\_cond的线程，可被调度  
if (pthread\_cond\_signal(&m\_cond))  
\{  
pthread\_mutex\_unlock(&m\_mutex);  
cout<<"cannot signal semaphore"<<endl;  
\}  
pthread\_mutex\_unlock(&m\_mutex);  
\}

//------------------------------------------------------------------------

/\*

信号量同步机制  
信号量提供一个计数值，可以进行原子操作。V 将计数值加1，使得  
等待该信号量的线程可以被调用（调用Set()），P 将计数值减1，使  
当前线程被挂起，进行睡眠（调用Wait()）。  
当信号量的计数值被初始化为0时，调用P操作，将挂起当前线程。  
当信号量被激活，即调用V操作后，被挂起的线程就有机会被重新调度了。

\*/

class CMySemaphore: private CSemaphoreImpl  
\{  
public:

/\*  
创建一个信号量，信号量计数值当前值为参数n，最大值为max。  
如果只有n，则n必须大于0；如果同时有n和max,则n必须不小  
于0，且不大于max  
\*/  
CMySemaphore(int n);  
CMySemaphore(int n, int max);

/\*  
销毁一个信号量  
\*/  
~CMySemaphore();

/\*  
对信号量计数值做加1动作，信号量变为有信号状态，使得  
另一个等待该信号量的线程可以被调度  
\*/  
void Set();

/\*  
对信号量计数值做减1动作，信号量变为无信号状态。若  
计数值变得大于0时，信号量才会变为有信号状态。  
\*/  
void Wait();

/\*  
在给定的时间间隔里等待信号量变为有信号状态，若成功，  
则将计数值减1，否则将发生超时。  
\*/  
void Wait(long lMilliseconds);

/\*  
在给定的时间间隔里等待信号量变为有信号状态，若成功，  
则将计数值减1，返回true；否则返回false。  
\*/  
bool TryWait(long lMilliseconds);

private:  
CMySemaphore();  
CMySemaphore(const CMySemaphore&);  
CMySemaphore& operator = (const CMySemaphore&);  
\};

inline void CMySemaphore::Set()  
\{  
SetImpl();  
\}

inline void CMySemaphore::Wait()  
\{  
WaitImpl();  
\}

inline void CMySemaphore::Wait(long lMilliseconds)  
\{  
if (!WaitImpl(lMilliseconds))  
cout<<"time out"<<endl;  
\}

inline bool CMySemaphore::TryWait(long lMilliseconds)  
\{  
return WaitImpl(lMilliseconds);  
\}

\#endif

MySemaphore.cpp  
view plain  
\#include "MySemaphore.h"  
\#include <sys/time.h>

CSemaphoreImpl::CSemaphoreImpl(int n, int max): m\_n(n), m\_max(max)  
\{  
assert (n >= 0 && max > 0 && n <= max);

if (pthread\_mutex\_init(&m\_mutex, NULL))  
cout<<"cannot create semaphore (mutex)"<<endl;  
if (pthread\_cond\_init(&m\_cond, NULL))  
cout<<"cannot create semaphore (condition)"<<endl;  
\}

CSemaphoreImpl::~CSemaphoreImpl()  
\{  
pthread\_cond\_destroy(&m\_cond);  
pthread\_mutex\_destroy(&m\_mutex);  
\}

void CSemaphoreImpl::WaitImpl()  
\{  
if (pthread\_mutex\_lock(&m\_mutex))  
cout<<"wait for semaphore failed (lock)"<<endl;  
while (m\_n < 1)  
\{  
//对互斥体进行原子的解锁工作,然后等待状态信号  
if (pthread\_cond\_wait(&m\_cond, &m\_mutex))  
\{  
pthread\_mutex\_unlock(&m\_mutex);  
cout<<"wait for semaphore failed"<<endl;  
\}  
\}  
\--m\_n;  
pthread\_mutex\_unlock(&m\_mutex);  
\}

bool CSemaphoreImpl::WaitImpl(long lMilliseconds)  
\{  
int rc = 0;  
struct timespec abstime;  
struct timeval tv;  
gettimeofday(&tv, NULL);  
abstime.tv\_sec = tv.tv\_sec + lMilliseconds / 1000;  
abstime.tv\_nsec = tv.tv\_usec\*1000 + (lMilliseconds % 1000)\*1000000;  
if (abstime.tv\_nsec >= 1000000000)  
\{  
abstime.tv\_nsec -= 1000000000;  
abstime.tv\_sec++;  
\}

if (pthread\_mutex\_lock(&m\_mutex) != 0)  
cout<<"wait for semaphore failed (lock)"<<endl;  
while (m\_n < 1)  
\{  
//自动释放互斥体并且等待m\_cond状态,并且限制了最大的等待时间  
if ((rc = pthread\_cond\_timedwait(&m\_cond, &m\_mutex, &abstime)))  
\{  
if (rc == ETIMEDOUT) break;  
pthread\_mutex\_unlock(&m\_mutex);  
cout<<"cannot wait for semaphore"<<endl;  
\}  
\}  
if (rc == 0) --m\_n;  
pthread\_mutex\_unlock(&m\_mutex);  
return rc == 0;  
\}

CMySemaphore::CMySemaphore(int n): CSemaphoreImpl(n, n)  
\{  
\}

CMySemaphore::CMySemaphore(int n, int max): CSemaphoreImpl(n, max)  
\{  
\}

CMySemaphore::~CMySemaphore()  
\{  
\}

下边是测试代码  
view plain  
// pthread\_semaphore.cpp : 定义控制台应用程序的入口点。  
//

\#include "MySemaphore.h"

//创建一个信号量，其计数值当前值为0，最大值为3  
CMySemaphore g\_MySem(0, 3);

//线程函数  
void \* StartThread(void \*pParam)  
\{  
//休眠1秒，确保主线程函数main中  
//创建工作线程下一句g\_MySem.Set();先执行  
sleep(1);

g\_MySem.Wait(); //信号量计数值减1

cout<<"Do print StartThread"<<endl;

return (void \*)0;  
\}

int main(int argc, char\* argv\[\])  
\{  
pthread\_t thread;  
pthread\_attr\_t attr;

assert ( !g\_MySem.TryWait(10) );

g\_MySem.Set(); //信号量计数值加1

g\_MySem.Wait(); //信号量计数值减1

try  
\{  
g\_MySem.Wait(100);  
cout<<"must timeout"<<endl; //此处发生超时  
\}  
catch (...)  
\{  
cout<<"wrong exception"<<endl;  
\}

g\_MySem.Set();  
g\_MySem.Set();  
assert ( g\_MySem.TryWait(0) );  
g\_MySem.Wait();  
assert ( !g\_MySem.TryWait(10) );

//创建工作线程  
pthread\_attr\_init(&attr);  
pthread\_attr\_setdetachstate(&attr,PTHREAD\_CREATE\_JOINABLE);  
if (pthread\_create(&thread,&attr, StartThread,NULL) == -1)  
\{  
cout<<"StartThread: create failed"<<endl;  
\}

g\_MySem.Set();

//等待线程结束  
void \*result;  
pthread\_join(thread,&result);

assert ( !g\_MySem.TryWait(10) ); //若将断言中的 ! 去掉，则会发生断言错误

//关闭线程句柄，释放资源  
pthread\_attr\_destroy(&attr);

int iWait;  
cin>>iWait;  
return 0;  
\}

编译，运行。可以看到，与Win32平台上的测试结果相同

由此可见，信号量机制很关键的一点就是计数值 m\_n

[linux]: http://www.9%3ca%20class=/
[linux 1]: http://linux.chinaitlab.com/
[Link 1]: http://softtest.chinaitlab.com/