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

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

    使用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，可以在http://www.9linux.com找到各API的说明。下边，是封装的信号量类，以及测试代码。使用VS2005编辑，在虚拟机 Fedora 13中编译，测试通过。

MySemaphore.h

 #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

 #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()
 {
 }

    下边是测试代码

 // 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。

原创作品，欢迎转载，麻烦带上链接：http://blog.csdn.net/chexlong/article/details/7098813 谢谢合作！