Linux 互斥锁的简单封装

lock.h

#ifndef __LOCK_H_
#define __LOCK_H_

#include <pthread.h>

//互斥锁类
class CMutex
{
public:
 typedef pthread_mutex_t Mutex_T;
 typedef pthread_mutexattr_t Mattr_T;
 typedef int MType_T;

public:
 CMutex();
 CMutex(MType_T type_t);
 ~CMutex();

public:
 int Lock()
 {
  return pthread_mutex_lock(&m_mutex);
 }

 int Unlock()
 {
  return pthread_mutex_unlock(&m_mutex);
 }

 int Trylock()
 {
  return pthread_mutex_trylock(&m_mutex);
 }

 Mutex_T& GetMutex()
 {
  return m_mutex;
 }

private:
  Mutex_T m_mutex;
  Mattr_T m_attr;
};

class CMAutoLock //对线程互斥锁的控制类
{
public:
 explicit CMAutoLock(CMutex& mutex) : m_lock(mutex)
 {
  m_lock.Lock();
 }
 ~CMAutoLock()
 {
  m_lock.Unlock();
 }

private:
 CMutex& m_lock;

private:
 CMAutoLock operator=(const CMAutoLock& mutex);
 CMAutoLock(const CMAutoLock& mutex)
};

//读写锁类
class CRWLock
{
public:
 typedef pthread_rwlock_t RWLock_T;

public:
 CRWLock();

 ~CRWLock();

public:
 int RLock()
 {
  return pthread_rwlock_rdlock(&m_rwlock);
 }

 int WLock()
 {
  return pthread_rwlock_wrlock(&m_rwlock);
 }

 int TryRLock()
 {
  return pthread_rwlock_tryrdlock(&m_rwlock);
 }

 int TryWLock()
 {
  return pthread_rwlock_trywrlock(&m_rwlock);
 }

 int Unlock()
 {
  return pthread_rwlock_unlock(&m_rwlock);
 }

private:
 RWLock_T m_rwlock;
};

class CCond //条件变量类
{
public:
 typedef pthread_cond_t Cond_T;

public:
 CCond();
 ~CCond();

public:
 int Lock()
 {
  return m_lock.Lock();
 }

 int Unlock()
 {
  return m_lock.Unlock();
 }

 int Trylock()
 {
  return m_lock.Trylock();
 }

 bool Wait()
 {
  return 0 == pthread_cond_wait(&m_cond, &m_lock.GetMutex());
 }

 bool Wait( long int sencond ); //此函数非内联

 void Signal()
 {
  pthread_cond_signal(&m_cond);
 }

 void Broadcast()
 {
  pthread_cond_broadcast(&m_cond);
 }

private:
 Cond_T m_cond;
 CMutex m_lock; //互斥锁
};

#endif

lock.cpp


#include "lock.h"

#include <sys/time.h>

//互斥锁类
CMutex::CMutex()
{
 pthread_mutexattr_init(&m_attr);
 pthread_mutexattr_settype(&m_attr,PTHREAD_MUTEX_NORMAL);
 pthread_mutex_init(&m_mutex,&m_attr);
}
CMutex::CMutex(MType_T type_t)
{
 pthread_mutexattr_init(&m_attr);
 pthread_mutexattr_settype(&m_attr,type_t);
 pthread_mutex_init(&m_mutex,&m_attr);
}
CMutex::~CMutex()
{
 pthread_mutex_destroy(&m_mutex);
 pthread_mutexattr_destroy(&m_attr);
}

//读写锁类
CRWLock::CRWLock()
{
 pthread_rwlock_init(&m_rwlock,NULL);
}
CRWLock::~CRWLock()
{
 pthread_rwlock_destroy(&m_rwlock);
}

//条件变量类
CCond::CCond()
{
 pthread_cond_init(&m_cond,NULL);
}

CCond::~CCond()
{
 pthread_cond_destroy(&m_cond);
}

bool CCond::Wait( long int sencond )
{
 timespec tsp;
 struct timeval now;
 gettimeofday( &now, NULL );
 sencond += now.tv_sec;
 tsp.tv_sec = now.tv_sec + sencond;
 tsp.tv_nsec = now.tv_usec*1000 ;

 return 0 == pthread_cond_timedwait( &m_cond, &m_lock.GetMutex(), &tsp );
}