多线程同步对象汇总

多线程同步对象汇总 

1。包括常用的互斥锁，条件变量和读写锁，使用了c++ 的构造锁定和析构解锁的原理，能方便安全的使用。

2。目前windows 只是支持临界区，linux 的都支持。

3。不支持循环递归锁定，需要自己判断。否则会死锁。

 

 

//头文件myosmutex.h

#ifndef _MYOSMUTEX_H_

#define _MYOSMUTEX_H_ 

#ifdef WIN32

#include <process.h>

#include <windows.h>

class MyOSMutex

{

private:

MyOSMutex(const MyOSMutex&);

MyOSMutex& operator=(const MyOSMutex&);

public:

MyOSMutex();

~MyOSMutex();

void lock();

void unlock();

bool trylock();

private:

CRITICAL_SECTION m_mutex;

};

#else

#include <sys/errno.h>

#include <pthread.h>

#include <sys/time.h>

class CThreadCond

{

private:

CThreadCond(const CThreadCond&);

CThreadCond& operator=(const CThreadCond&);

//

pthread_cond_t m_cond;

public:

CThreadCond();

~CThreadCond();

//

template <typename T> bool wait(const T& mutex,unsigned int millisecond = 0);

//

bool notifyall();

};

class MyOSMutex

{

private:

MyOSMutex(const MyOSMutex&);

MyOSMutex& operator=(const MyOSMutex&);

public:

MyOSMutex();

~MyOSMutex();

void lock();

void unlock();

bool trylock();

private:

pthread_mutex_t m_mutex;

friend class CThreadCond;

};

class CReadWriteLock

{

private:

CReadWriteLock(const CReadWriteLock&);

CReadWriteLock& operator=(const CReadWriteLock&);

protected:

pthread_rwlock_t m_rwlock;

public:

CReadWriteLock();

~CReadWriteLock();

void readlock();

void writelock();

void unlock();

bool tryreadlock();

bool trywritelock();

};

class CReadLock

{

private:

CReadWriteLock &m_lock;

CReadLock(const CReadLock&);

CReadLock& operator=(const CReadLock&);

public:

CReadLock(CReadWriteLock &lock);

void lock();

void unlock();

bool trylock();

};

class CWriteLock

{

private:

CReadWriteLock &m_lock;

CWriteLock(const CWriteLock&);

CWriteLock& operator=(const CWriteLock&);

public:

CWriteLock(CReadWriteLock &lock);

void lock();

void unlock();

bool trylock();

};

#endif

template <typename T> class CAutoLock

{

private:

T &m_mutex;

CAutoLock(const CAutoLock&);

CAutoLock& operator=(const CAutoLock&);

private:

void lock();

void unlock();

bool trylock();

public:

CAutoLock(T &lock);

~CAutoLock();

};

#endif 

 

 

//cpp 文件

#include "myosmutex.h"

#include <assert.h>

#include <time.h>

template <typename T> bool CThreadCond::wait(const T& mutex,unsigned int millisecond)

{

int result = 0;

if(millisecond > 0)

{

struct timeval tv;

gettimeofday(&tv,0);

struct timespec ts;

ts.tv_sec = tv.tv_sec;

ts.tv_nsec = tv.tv_usec * 1000;

ts.tv_sec += (millisecond / 1000);

ts.tv_nsec += (millisecond % 1000) * 1000000;

result = pthread_cond_timedwait(&m_cond,&mutex.m_mutex,&ts);

}

else

{

result = pthread_cond_wait(&m_cond,&mutex.m_mutex);

}

return result == 0;

}

bool CThreadCond::notifyall()

{

int result = pthread_cond_broadcast(&m_cond);

return result == 0;

}

MyOSMutex::MyOSMutex()

{

#ifdef WIN32

::InitializeCriticalSection(&m_mutex);

#else

(void)pthread_mutex_init(&m_mutex,0);

#endif

}

MyOSMutex::~MyOSMutex()

{

#ifdef WIN32

::DeleteCriticalSection(&m_mutex);

#else

pthread_mutex_destroy(&m_mutex);

#endif

}

void  MyOSMutex::lock()

{

#ifdef WIN32

::EnterCriticalSection(&m_mutex);

#else

(void)pthread_mutex_lock(&m_mutex);

#endif

}

void  MyOSMutex::unlock()

{

#ifdef WIN32

::LeaveCriticalSection(&m_mutex);

#else

pthread_mutex_unlock(&m_mutex);

#endif

}

bool MyOSMutex::trylock()

{ 

#ifdef WIN32

// Return values of this function match our API

//#define _WIN32_WINNT 0x0500

/*

if(::TryEnterCriticalSection(&m_mutex) == 0)

{  return false;

}

*/

#else

int theErr = pthread_mutex_trylock(&m_mutex);

if(theErr != 0)

{

assert(theErr == EBUSY);

return false;

}

#endif

return true;

}

CReadWriteLock::CReadWriteLock()

{

pthread_rwlock_init(&m_rwlock,0);

}

CReadWriteLock::~CReadWriteLock()

{

pthread_rwlock_destroy(&m_rwlock);

}

void CReadWriteLock::readlock()

{

pthread_rwlock_rdlock(&m_rwlock);

}

void CReadWriteLock::writelock()

{

pthread_rwlock_wrlock(&m_rwlock);

}

void CReadWriteLock::unlock()

{

pthread_rwlock_unlock(&m_rwlock);

}

bool CReadWriteLock::tryreadlock()

{

int result = 0;

result = pthread_rwlock_tryrdlock(&m_rwlock);

return result == 0?true:false;

}

bool CReadWriteLock::trywritelock()

{

int result = 0;

result = pthread_rwlock_trywrlock(&m_rwlock);

return result == 0?true:false;

}

CReadLock::CReadLock(CReadWriteLock &lock):m_lock(lock)

{

//

}

void CReadLock::lock()

{

m_lock.readlock();

}

void CReadLock::unlock()

{

m_lock.unlock();

}

bool CReadLock::trylock()

{

return m_lock.tryreadlock();

}

CWriteLock::CWriteLock(CReadWriteLock &lock):m_lock(lock)

{

//

}

void CWriteLock::lock()

{

m_lock.writelock();

}

void CWriteLock::unlock()

{

m_lock.unlock();

}

bool CWriteLock::trylock()

{

return m_lock.trywritelock();

}

template <typename T> CAutoLock<T>::CAutoLock(T &lock):m_mutex(lock)

{

m_mutex.lock();

}

template <typename T> CAutoLock<T>::~CAutoLock()

{

m_mutex.unlock();

}

//模板类中的成员函数在类外定义 

template <typename T> bool CAutoLock<T>::trylock()

{

return m_mutex.trylock();

}

CThreadCond::CThreadCond()

{

pthread_cond_init(&m_cond,0);

}

CThreadCond::~CThreadCond()

{

pthread_cond_destroy(&m_cond);

}