普通对象智能指针模板类

// 互斥体
#ifdef WIN32
class Mutex
{
public:
Mutex(bool = true){ ::InitializeCriticalSection(&m_cs); }
~Mutex(){ ::DeleteCriticalSection(&m_cs); }
void Lock(){ ::EnterCriticalSection(&m_cs); }
void Unlock(){ ::LeaveCriticalSection(&m_cs); }
// bool TryLock(){ return ::TryEnterCriticalSection(&m_cs); }
private:
CRITICAL_SECTION m_cs;
};
#else
class Mutex
{
public:
Mutex(bool recursive = true)
{
if(recursive)
{
pthread_mutexattr_t attr;
::pthread_mutexattr_init(&attr);
::pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
::pthread_mutex_init(&m_mutex, &attr);
::pthread_mutexattr_destroy(&attr);
}
else
{
::pthread_mutex_init(&m_mutex, NULL);
}
}
~Mutex(){ ::pthread_mutex_destroy(&m_mutex); }
void Lock(){ ::pthread_mutex_lock(&m_mutex); }
void Unlock(){ ::pthread_mutex_unlock(&m_mutex); }
// bool TryLock(){ return ::pthread_mutex_trylock(&m_mutex) == 0; }
private:
pthread_mutex_t m_mutex;
};
#endif


// 伪互斥体
class FakeMutex
{
public:
FakeMutex(bool = true){}
void Lock(){}
void Unlock(){}
};


// 临界区线程安全自动保护
template<class Mutex = Mutex>
class ResGuard
{
public:
ResGuard(Mutex& mtx) : m_mtx(mtx){ m_mtx.Lock(); }
~ResGuard(){ m_mtx.Unlock(); }
private:
Mutex& m_mtx;
};


// 单线程模型，自增减没有互斥处理
class SingleThread
{
public:
static long _Increment(long* p){ return ++(*p); }
static long _Decrement(long* p){ return --(*p); }
typedef FakeMutex _Mutex;
};


// 多线程模型，自增减互斥处理
class MultiThread
{
public:
static long _Increment(long* p){ return ::InterlockedIncrement(p); }
static long _Decrement(long* p){ return ::InterlockedDecrement(p); }
typedef Mutex _Mutex;
};


// 信号量
#ifdef WIN32
class Semaphore
{
HANDLE m_h;
public:
Semaphore(int initCount = 0)
{
ASSERT_(initCount >= 0);
m_h = ::CreateSemaphore(NULL, initCount, 0x7fffffff, NULL);
ASSERT_(m_h);
}
~Semaphore(){ if(m_h) ::CloseHandle(m_h); }
BOOL Wait(ULONG timeOut = INFINITE)
{
ASSERT_(m_h);
DWORD ret = ::WaitForSingleObject(m_h, timeOut);
if(ret == WAIT_OBJECT_0) return TRUE;
ASSERT_(ret == WAIT_TIMEOUT);
return FALSE;
}
void Post(){ ASSERT_(m_h); BOOL bret = ::ReleaseSemaphore(m_h, 1, NULL); ASSERT_(bret); }
};
#else
class Semaphore
{
sem_t m_sem;
public:
Semaphore(int initCount = 0)
{
ASSERT_(initCount >= 0);
int ret = ::sem_init(&m_sem, 0, initCount);
ASSERT_(ret == 0);
}
~Semaphore(){ ::sem_destroy(&m_sem); }
BOOL Wait(ULONG timeOut = 0xffffffff)
{
int ret = 0;
if(timeOut == 0xffffffff)
{
while(1)
{
ret = ::sem_wait(&m_sem);
if(ret == 0) return TRUE;
ASSERT_(::GetLastError() == EINTR);
}
}
else
{
timespec ts;
ret = ::clock_gettime(CLOCK_REALTIME, &ts);
ASSERT_(ret == 0);
ts.tv_sec += timeOut / 1000;
ts.tv_nsec += (timeOut % 1000) * 1000000;
if(ts.tv_nsec >= 1000000000)
{
ts.tv_sec += 1;
ts.tv_nsec -= 1000000000;
}
while(1)
{
ret = ::sem_timedwait(&m_sem, &ts);
if(ret == 0) return TRUE;
if(::GetLastError() == EINTR) continue;
ASSERT_(::GetLastError() == ETIMEDOUT);
return FALSE;
}
}
ASSERT_(0);
return FALSE;
}
void Post(){ int ret = ::sem_post(&m_sem); ASSERT_(ret == 0); }
};

#endif

// 计数器类
template<class ThreadModel = SingleThread>
class Counter
{
public:
Counter() : _m_val(0){}
long _Increment(){ return ThreadModel::_Increment(&_m_val); }
long _Decrement(){ return ThreadModel::_Decrement(&_m_val); }
long _GetCount(){ return _m_val; }
private:
long _m_val;
};


template<class T>
class _MemPtr : public T
{
public:
_MemPtr(){}
private:
long _Increment();
long _Decrement();
};
// 普通对象智能指针模板类，参数T必须从Counter继承
template<class T>
class MemPtr
{
public:
MemPtr() : m_p(NULL){}
MemPtr(T* p) : m_p(p){ AddRef(); }// ，
MemPtr(const MemPtr<T>& s) : m_p(s.m_p){ AddRef(); }
~MemPtr(){ Release(); }
MemPtr<T>& operator=(const MemPtr<T>& r)
{
if(m_p != r.m_p){ Release(); m_p = r.m_p; AddRef(); }
return *this;
}
operator T*() { return m_p; } //这是一个类型转换操作符 可以这样使用 T* a = MemPtr<T>();
_MemPtr<T>* operator->() const { return (_MemPtr<T>*)m_p; }
bool operator==(const MemPtr<T>& r) const{ return m_p == r.m_p; }
bool operator!=(const MemPtr<T>& r) const{ return m_p != r.m_p; }
bool operator!() const{ return !m_p; }
operator bool() const{ return m_p != NULL; }
void Attach(T* p){ Release(); m_p = p; }
T* Detach(){ T* p = m_p; m_p = NULL; return p; }
void Release()
{
if(m_p)
{
if(m_p->_Decrement() == 0){ delete m_p; }
m_p = NULL;
}
}
T* Copy() { AddRef(); return m_p; }
long GetRef() const// Used for debugging
{
if(m_p) return m_p->_GetCount(); return -1;
}
T* m_p; // 请勿直接改写此变量
protected:
void AddRef(){ if(m_p) m_p->_Increment(); }
};