xlock.h

封装了C++调用Java功能的功能！JNI,javaVM

/*-  @filedef
-*  
-*  	@copyright (c) 2006 XW
-*  
-*  @description:
-*  		Lock类的文件
-*  
-*  @create :
-*  	@date	:  2007-2-25
-*  	@time	:  19:31:51
-*  	@author	: XiaoWei
-*  
-*  
-*  @file		: XLock.h
-*  @version	: 1.0.0.0
-*  @note		: <XLock>
-*  
-*/
#if !defined(__XLock_h__)
#define __XLock_h__

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000


#include <windows.h>
#include <assert.h>


/*-  @typedef
-*  
-*  @class 	:  XNullLock
-*  
-*  @description:
-*  			没有琐
-*  
-*  @create :
-*   	@date	:  2007-2-25
-*   	@time	:  19:31:51
-*   	@author	:  XiaoWei
-*  
-*/
class XNullLock  
{
 
public:
	
	inline XNullLock() { }
	
	
	inline ~XNullLock() {  }
	
	inline void acquire() { 
	}
	
	
	inline void release() { 
	}
    
	
	inline bool tryAcquire(unsigned long timeout=0) { 
		return true;
	}
	
};



/*-  @typedef
-*  
-*  @class 	:  XAtomicLock
-*  
-*  @description:
-*  			原子琐
-*  
-*  @create :
-*   	@date	:  2007-2-25
-*   	@time	:  19:31:51
-*   	@author	:  XiaoWei
-*  
-*/
class XAtomicLock  
{
private: 
#pragma pack(push, 8)
	long volatile _lock;
#pragma pack(pop)
	
public:
	
	inline XAtomicLock() : _lock(0) { }
	
	
	inline ~XAtomicLock() { assert(_lock == 0); }
	
	inline void acquire() { 
		while (::InterlockedCompareExchange(const_cast<void**>((void**)&_lock), reinterpret_cast<void*>(1), 0) != 0)
			::Sleep(0); 
	}
	
	
	inline void release() { 
		::InterlockedExchange(const_cast<long*>(&_lock), (LONG)0); 
	}
    
	
	inline bool tryAcquire(unsigned long timeout=0) { 
		return ::InterlockedCompareExchange(const_cast<void**>((void**)&_lock), reinterpret_cast<void*>(1), 0) == 0; 
	}
	
};



/*-  @typedef
-*  
-*  @class 	:  XCSLock
-*  
-*  @description:
-*  		 临界琐	
-*  
-*  @create :
-*   	@date	:  2007-2-25
-*   	@time	:  19:31:51
-*   	@author	:  XiaoWei
-*  
-*/
class XCSLock
{
	
public:
	XCSLock(){
		InitializeCriticalSection(&m_cs);
	}
	
	~XCSLock(){
		::DeleteCriticalSection(&m_cs);
	} 
	
	inline void acquire() { 
		::EnterCriticalSection(&m_cs); 
		
	}
	
	
	inline void release() { 
		::LeaveCriticalSection(&m_cs);
		
	}
    
	
	inline bool tryAcquire(unsigned long timeout=0) { 
		::EnterCriticalSection(&m_cs); 
		return true;
	}
	 
private:
	CRITICAL_SECTION m_cs; 
};


class XMutexLock{
	
	   HANDLE m_hMutex;
public:
	
	XMutexLock(){
		m_hMutex = ::CreateMutex(0, 0, 0);  
	}
	
	
	~XMutexLock() {
		::CloseHandle(m_hMutex);
	}
	
	void acquire() {
		
		if(::WaitForSingleObject(m_hMutex, INFINITE) != WAIT_OBJECT_0) {
			assert(0);
		}  
	}
	
	void release() { 
		
		if(::ReleaseMutex(m_hMutex) == 0) {
			assert(0);
		}
	}
	
	
	bool tryAcquire(unsigned long timeout = 0) {
		
		switch(::WaitForSingleObject(m_hMutex, timeout)) {
		case WAIT_OBJECT_0: 
			return true;
		case WAIT_TIMEOUT:
			return false;
		default:
			break;
		}
		
		return true;
	}
};



template<typename _Lock>
class XGuard
{
	_Lock & m_lock;
public:
	XGuard(_Lock & _lock ):m_lock(_lock)
	{
		m_lock.acquire();
	}


	XGuard(_Lock & _lock ,unsigned long _time):m_lock(_lock)
	{
		m_lock.tryAcquire(_time);
	}

	~XGuard( )
	{
		m_lock.release();
	}

};


typedef		XGuard<XCSLock>			_XCSLock;

typedef		XGuard<XNullLock>		_XNullLock;

#endif // !defined(__XLock_h__)