lock.h

网络socket,IO,线程池

/*
   2003 by zhy
*/
#ifndef _MY_LOCK_H
#define _MY_LOCK_H

#pragma warning(disable:4786)

#include <windows.h>


#include "../include/exception.h"
using namespace CommonInclude;

#include <string>
using namespace std;

namespace Synchronization{

//Exception class
class CMutexException : public CExceptionBase
{
public:
	explicit CMutexException(int nCode,const char *_Message) throw () : CExceptionBase(nCode,_Message) {}
	CMutexException(const CMutexException & re) throw () : CExceptionBase(re) {}
};


// 采用关键区特点是用户态，速度快，但无法跨进程
class CCriSection
{
public:
    CCriSection()
	{
       m_iCount = 0;
	   ::InitializeCriticalSection(&mcri_);
	}
	~CCriSection()
	{
	   ::DeleteCriticalSection(&mcri_);
	}

	//用于调试时发现是否有线程进入关键区
	bool IsLock()
	{
		return m_iCount>0;
	}

	void acquire() throw(CMutexException);
	void release() throw(CMutexException);
private:
	CRITICAL_SECTION mcri_;
	int              m_iCount;
};

//可以跨进程的关键区暂时没有实现

//采用CreateMutex实现的Mutex,内核对象，速度慢，但可以跨进程
class CAPIMutex
{
public:
	CAPIMutex(const char* szMutexName = NULL ,bool bHaveName = false):m_bHaveName(bHaveName)
	{
		m_hmutex = NULL;
		if(m_bHaveName)
			m_mutexName = szMutexName;
	}
    ~CAPIMutex() {}
	
	bool IsOpen();
	void SetMutexName(const char* szMutexName);

    void acquire() throw(CMutexException);
	void release() throw(CMutexException);
private:
	HANDLE m_hmutex; 
	string m_mutexName;
	bool   m_bHaveName;
};



//demand all paparmized type Mutex have acquire()
//and release funtion
//if there is no ,you should write a adapter
template<class Mutex>
class CLock
{
public:
    CLock(Mutex& mutex):_mutex(mutex)
	{
		_mutex.acquire();
	}

	~CLock()
	{
		_mutex.release();
	}
private:
	Mutex& _mutex;
};


//以下对象级或类级锁的用法：
//class My:public ObjectLevelLockable<My>
// {
// public:
//	 void de()
//	 {
//		 Lock lock(*this);
//	 }
//   };
template <class Host>
class ObjectLevelLockable
{
	CRITICAL_SECTION mtx_;
	
public:
	ObjectLevelLockable()
	{
		::InitializeCriticalSection(&mtx_);
	}
	
	~ObjectLevelLockable()
	{
		::DeleteCriticalSection(&mtx_);
	}
	
	class Lock;
	friend class Lock;
	
	class Lock
	{
		ObjectLevelLockable& host_;
		
		Lock(const Lock&);
		Lock& operator=(const Lock&);
	public:
		
		explicit Lock(ObjectLevelLockable& host) : host_(host)
		{
			::EnterCriticalSection(&host_.mtx_);
		}
		
		~Lock()
		{
			::LeaveCriticalSection(&host_.mtx_);
		}
	};
	
	typedef volatile Host VolatileType;
	
	typedef LONG IntType; 
	
	static IntType AtomicIncrement(volatile IntType& lval)
	{ return InterlockedIncrement(&const_cast<IntType&>(lval)); }
	
	static IntType AtomicDecrement(volatile IntType& lval)
	{ return InterlockedDecrement(&const_cast<IntType&>(lval)); }
	
	static void AtomicAssign(volatile IntType& lval, IntType val)
	{ InterlockedExchange(&const_cast<IntType&>(lval), val); }
	
	static void AtomicAssign(IntType& lval, volatile IntType& val)
	{ InterlockedExchange(&lval, val); }
};

template <class Host>
class ClassLevelLockable
{
     public:
		 struct Initializer
		 {   
			 CRITICAL_SECTION mtx_;
			 
			 Initializer()
			 {
				 ::InitializeCriticalSection(&mtx_);
			 }
			 ~Initializer()
			 {
				 ::DeleteCriticalSection(&mtx_);
			 }
		 };
		 
		 static Initializer initializer_;
		 
		 //public:
		 class Lock;
		 friend class Lock;
		 
		 class Lock
		 {
			 Lock(const Lock&);
			 Lock& operator=(const Lock&);
		 public:
			 Lock()
			 {
				 ::EnterCriticalSection(&initializer_.mtx_);
			 }
			 explicit Lock(ClassLevelLockable&)
			 {
				 ::EnterCriticalSection(&initializer_.mtx_);
			 }
			 ~Lock()
			 {
				 ::LeaveCriticalSection(&initializer_.mtx_);
			 }
		 };
		 
		 typedef volatile Host VolatileType;
		 
		 typedef LONG IntType; 
		 
		 static IntType AtomicIncrement(volatile IntType& lval)
		 { return InterlockedIncrement(&const_cast<IntType&>(lval)); }
		 
		 static IntType AtomicDecrement(volatile IntType& lval)
		 { return InterlockedDecrement(&const_cast<IntType&>(lval)); }
		 
		 static void AtomicAssign(volatile IntType& lval, IntType val)
		 { InterlockedExchange(&const_cast<IntType&>(lval), val); }
		 
		 static void AtomicAssign(IntType& lval, volatile IntType& val)
		 { InterlockedExchange(&lval, val); }
};
    

}

#endif