text: #ifndef LOCKER_H
  #define LOCKER_H
  
  #include <exception>
  #include <pthread.h>
  #include <semaphore.h>
  
  class sem
  {
  public:
      sem()
      {
          if (sem_init(&m_sem, 0, 0) != 0)
          {
              throw std::exception();
          }
      }
      sem(int num)
      {
          if (sem_init(&m_sem, 0, num) != 0)
          {
              throw std::exception();
          }
      }
      ~sem()
      {
          sem_destroy(&m_sem);
      }
      bool wait()
      {
          return sem_wait(&m_sem) == 0;
      }
      bool post()
      {
          return sem_post(&m_sem) == 0;
      }
  
  private:
      sem_t m_sem;
  };
  class locker
  {
  public:
      locker()
      {
          // 原型 int WINPTHREAD_API pthread_mutex_init(pthread_mutex_t *m, const pthread_mutexattr_t *a);
          if (pthread_mutex_init(&m_mutex, NULL) != 0)
          {
              throw std::exception();
          }
      }
      ~locker()
      {
          pthread_mutex_destroy(&m_mutex);
      }
      bool lock()
      {
          return pthread_mutex_lock(&m_mutex) == 0;
      }
      bool unlock()
      {
          return pthread_mutex_unlock(&m_mutex) == 0;
      }
      pthread_mutex_t *get()
      {
          return &m_mutex;
      }
  
  private:
      // 互斥锁，多线程对于共享变量的保护。
      pthread_mutex_t m_mutex;
  };
  class cond
  {
  public:
      cond()
      {
          if (pthread_cond_init(&m_cond, NULL) != 0)
          {
              //pthread_mutex_destroy(&m_mutex);
              throw std::exception();
          }
      }
      ~cond()
      {
          pthread_cond_destroy(&m_cond);
      }
      bool wait(pthread_mutex_t *m_mutex)
      {
          int ret = 0;
          //pthread_mutex_lock(&m_mutex);
          ret = pthread_cond_wait(&m_cond, m_mutex);
          //pthread_mutex_unlock(&m_mutex);
          return ret == 0;
      }
      bool timewait(pthread_mutex_t *m_mutex, struct timespec t)
      {
          int ret = 0;
          //pthread_mutex_lock(&m_mutex);
          ret = pthread_cond_timedwait(&m_cond, m_mutex, &t);
          //pthread_mutex_unlock(&m_mutex);
          return ret == 0;
      }
      bool signal()
      {
          return pthread_cond_signal(&m_cond) == 0;
      }
      bool broadcast()
      {
          return pthread_cond_broadcast(&m_cond) == 0;
      }
  
  private:
      //static pthread_mutex_t m_mutex;
      // 线程间同步
      pthread_cond_t m_cond;
  };
  #endif
  