sharememory.h

java程序五子棋源代码。 java程序五子棋源代码。

#if !defined(ShareMemory__INCLUDE_)
#define ShareMemory__INCLUDE_

template<class st> class CShareMemory
{
private:
	HANDLE m_hMutex;				//互斥锁
	HANDLE m_hShmFile;				//内存映像文件句柄
	char   m_csMutexName[200];		//互斥锁名称

	//共享内存头结构
	struct Node_Queue{
		int		Tail;				//当前节点数
		int		Size;				//分配的节点数
		char	offset[0];			//偏移
	};

	Node_Queue *queue;				//指向分配的共享内存

private:
	//互斥锁操作
	inline Lock(DWORD dwMilliSec=INFINITE);

	//解锁
	inline BOOL UnLock();

public:
	char	KeyName[200];			//共享内存键名称
	BOOL	IsExists;				//是否已经存在
	BOOL	IsInit;					//是否初始化

public:
	CShareMemory(const char *strKeyName);
	~CShareMemory();

	BOOL	Init(const int nNodeLength=500);
	BOOL	Insert(const st *node);
	int		GetNodes(st *node,const int nGetLengths=1);
	int		GetLength();
	int		GetSize();
};

template<class st> CShareMemory<st>::CShareMemory(const char *strKeyName)
{
	strcpy(KeyName,strKeyName);
	sprintf(m_csMutexName,"%sMutex",strKeyName);
	IsExists = FALSE;
	IsInit = FALSE;
}

template<class st> inline BOOL CShareMemory<st>::Lock(DWORD dwMilliSec)
{
	if(::WaitForSingleObject(m_hMutex,dwMilliSec) == WAIT_OBJECT_0)
		return TRUE;
	return FALSE;
}

template<class st> inline BOOL CShareMemory<st>::UnLock()
{
	return ::ReleaseMutex(m_hMutex);
}

//功能:共享内存初始化
//参数:nNodeLength分配的节点长度
//返回:[成功]TRUE  [失败]FALSE
//注意:在使用API的时候,不同的程序之间共享内存大小最好一致
template<class st> BOOL CShareMemory<st>::Init(const int nNodeLength)
{
	DWORD dwNumberOfShm = 0;

	if(nNodeLength <= 0){
		return FALSE;		
	}

	//创建互斥锁
	m_hMutex = ::CreateMutex(NULL,FALSE,m_csMutexName);
	if(m_hMutex == NULL){
		return FALSE;
	}

	//计算分配共享内存大小
	dwNumberOfShm = offsetof(Node_Queue,offset) + sizeof(st)*nNodeLength;

	m_hShmFile = ::CreateFileMapping((HANDLE)0xFFFFFFFF,
									NULL,
									PAGE_READWRITE,
									0,
									dwNumberOfShm,
									KeyName);
	if(m_hShmFile == NULL || m_hShmFile == INVALID_HANDLE_VALUE){
		return FALSE;
	}

	if(::GetLastError() == ERROR_ALREADY_EXISTS){
		IsExists = TRUE;
	}
	
	//映射地址空间
	queue = (Node_Queue *)::MapViewOfFile(m_hShmFile,
							FILE_MAP_WRITE,
							0,
							0,
							dwNumberOfShm);
	if(queue == NULL){
		IsInit = FALSE;
		::ReleaseMutex(m_hMutex);
		::CloseHandle(m_hShmFile);
        return FALSE;
	}
	else{
		IsInit = TRUE;
	}

	//第一次使用此内存块,则进行初始化Tail
	//以后使用此内存块,重新设置Size
	if(!IsExists){
		Lock();
		queue->Size = nNodeLength;
		queue->Tail = 0;
		UnLock();
	}
	else{
		Lock();
		queue->Size = nNodeLength;
		UnLock();
	}

	return TRUE;
}

//功能:向共享内存插入一个节点
//参数:pInsertNode是要插入的节点
//返回:[成功]TRUE  [失败]FALSE
template<class st> BOOL CShareMemory<st>::Insert(const st *pInsertNode)
{	
	if(!IsInit){
		return FALSE;
	}

	Lock();
	int nLoopTail = queue->Tail%queue->Size;
	//先强制转化queue为char *,以便做地址运算时按字节增加
	memcpy((char *)queue+offsetof(Node_Queue,offset)+sizeof(st)*nLoopTail,
			pInsertNode,
			sizeof(st)
		  );

	queue->Tail = (queue->Tail+1)%queue->Size;
	UnLock();

	return TRUE;
}

//功能:取共享内存的节点到node
//参数:pInsertNode是要插入的节点
//返回:[成功]返回取到的节点数  [失败]-1
template<class st> int CShareMemory<st>::GetNodes(st *node,const int nGetLengths)
{
	int nGetNums;

	if(!IsInit){
		return -1;
	}

	if(nGetLengths<1){
		return -1;
	}

	Lock();
	int nLength = queue->Tail%queue->Size;

	nGetNums = nLength;
	if(nGetLengths<nLength)
		nGetNums = nGetLengths;

	if(nLength > 0){
		//先强制转化queue为char *,以便做地址运算时按字节增加
		memcpy(node,(char *)queue+offsetof(Node_Queue,offset),sizeof(st)*nGetNums);

		if(nLength-nGetNums > 0){
			//搬移后面的节点
			memcpy((char *)queue+offsetof(Node_Queue,offset),
				   (char *)queue+offsetof(Node_Queue,offset)+sizeof(st)*nGetNums,
				   sizeof(st)*(nLength-nGetNums));
		}

		queue->Tail = nLength-nGetNums;
	}
	UnLock();
	return nGetNums;
}

//功能:取共享内存的节点数
//参数:
//返回:[成功]返回节点数  [失败]-1
template<class st> int CShareMemory<st>::GetLength()
{
	if(!IsInit){
		//未初始化
		return -1;
	}

	return queue->Tail%queue->Size;
}

//功能:取共享内存的大小
//参数:
//返回:[成功]返回节点数  [失败]-1
template<class st> int CShareMemory<st>::GetSize()
{
	if(!IsInit){
		//未初始化
		return -1;
	}

	return queue->Size;
}

template<class st> CShareMemory<st>::~CShareMemory()
{
	if(IsInit){
		::ReleaseMutex(m_hMutex);
		::CloseHandle(m_hMutex);
		::UnmapViewOfFile(queue);
		::CloseHandle(m_hShmFile);
	}
}

#endif