共享内存例子

// SharedMemory.h: interface for the CSharedMemory class.

//

//



#if !defined(AFX_SHAREDMEMORY_H__86467BA6_5AFA_11D3_863D_00A0244A9CA7__INCLUDED_)

#define AFX_SHAREDMEMORY_H__86467BA6_5AFA_11D3_863D_00A0244A9CA7__INCLUDED_



#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000



#include <process.h>



class CSharedMemory

{

private:

	class CWriteQueue

	{

	// This class is the queue, it contains a pointer to

	// a data block and a pointer to the next queue item.

	friend class CSharedMemory;

	private:

		CWriteQueue(int nDataSize)

		{

			pData = new BYTE[nDataSize];

			pNext = NULL;

		};

		~CWriteQueue()

		{

			delete [] pData;

		};

		void		*pData;

		CWriteQueue *pNext;

	};

public:

	enum

	{

		// Return values of the class-functions.

		MEM_ERROR_UNKNOWN		= -1,

		MEM_SUCCESS				= 0,

		MEM_ERROR_CLOSED		= 1,

		MEM_ERROR_TIMEOUT		= 2,

		MEM_ERROR_OTHERPARTY	= 3,

		MEM_ERROR_DATASIZE		= 4

	};

	CSharedMemory()

	{

		m_nOtherInstanceID	= 0;

		m_nInstanceID		= 0;

		// Create an event that indicates wether the connection

		// is open or not.

		m_hClosed		= CreateEvent(NULL, TRUE, TRUE, NULL);

		m_hDataWrit[0]	= NULL;

		m_hDataWrit[1]	= NULL;

		m_hDataRead[0]	= NULL;

		m_hDataRead[1]	= NULL;

		m_hDataInQueue	= NULL;

		m_hQueueMutex	= NULL;

	};

	virtual ~CSharedMemory()

	{

		Close();

		CloseHandle(m_hClosed);

	};

	bool Open(char* sName, int nDataSize, int nTimeOut = INFINITE)

	{

		m_pFirst	= NULL;



		// The connection must be closed before it can be opened.

		if (WaitForSingleObject(m_hClosed, 0) == WAIT_OBJECT_0)

		{

			// The name may not exceed MAX_PATH, we substract 10 because we

			// add some strings to the name in some code.

			if (strlen(sName) != 0 && strlen(sName) < MAX_PATH - 10)

			{

				// The datasize must be larger than 0.

				if (nDataSize > 0)

				{

					// The following mutexes can indicate 4 things:

					// - No instance of this shared memory class was created.

					// - The first instance of this class was created.

					// - The second instance of this shared memory class was created.

					// - Both instances were created.

					char sMutex0	[MAX_PATH];

					char sMutex1	[MAX_PATH];

					strcpy(sMutex0	, sName);

					strcpy(sMutex1	, sName);

					strcat(sMutex0	, "Mutex0");

					strcat(sMutex1	, "Mutex1");

					m_hSharedMemoryMutex[0] = CreateMutex(NULL, FALSE, sMutex0);

					m_hSharedMemoryMutex[1] = CreateMutex(NULL, FALSE, sMutex1);

					if (m_hSharedMemoryMutex[0] && m_hSharedMemoryMutex[1])

					{

						// Only two instances of this class (with this name) may reside on

						// one system. These will be referred to as 'm_nInstanceID and m_nOtherInstanceID'

						HANDLE hWait[2] = {m_hSharedMemoryMutex[0], m_hSharedMemoryMutex[1]};

						DWORD dwResult = WaitForMultipleObjects(2, hWait, FALSE, 0);

						if (dwResult == WAIT_OBJECT_0 || dwResult == (WAIT_OBJECT_0 + 1))

						{

							if ((m_nInstanceID = dwResult - WAIT_OBJECT_0) == 0)

								m_nOtherInstanceID = 1;

							else

								m_nOtherInstanceID = 0;



							char sName0		[MAX_PATH];

							char sName1		[MAX_PATH];

							strcpy(sName0	, sName);

							strcpy(sName1	, sName);

							strcat(sName0	, "0");

							strcat(sName1	, "1");



							// We will use two shared memory pools to provide duplex

							// communication.

							if ((m_hSharedMemory[0]	= CreateFileMapping(	(HANDLE)0xFFFFFFFF,

																			NULL,

																			PAGE_READWRITE,

																			0,

																			sizeof(int) + nDataSize,

																			sName0)) != NULL

																			&&			

								(m_hSharedMemory[1]	= CreateFileMapping(	(HANDLE)0xFFFFFFFF,

																			NULL,

																			PAGE_READWRITE,

																			0,

																			sizeof(int) + nDataSize,

																			sName1)) != NULL)

							{

								bool bFileMappingAlreadyExists = (GetLastError() == ERROR_ALREADY_EXISTS);



								// Now map a pointer to the size tag in the shared memory.

								m_pSize = (int*)MapViewOfFile(	m_hSharedMemory[0],

																	FILE_MAP_ALL_ACCESS,

																	0,

																	0,

																	sizeof(int));

								if (m_pSize)

								{

									bool bSharedMemorySizeOk = false;

									if (bFileMappingAlreadyExists)

									{

										// We will check if the size of the memory block is of the

										// same size as the block that was already allocated by another

										// instance of the shared memory class.

										// The size of the memory block is saved in the first integer

										// at the specified shared memory address.

										if (*m_pSize == nDataSize)

											bSharedMemorySizeOk = true;

									}

									else

									{

										// The memory was not allocated by another instance so we

										// have the honors to allocate it. This means also that we should

										// set the size of the memory that we have allocated in the first

										// integer of the shared memory space.

										*m_pSize = nDataSize;

										bSharedMemorySizeOk = true;

									}

									if (bSharedMemorySizeOk)

									{

										m_pSharedMemory[0] = (BYTE*)MapViewOfFile(	m_hSharedMemory[0],

																						FILE_MAP_ALL_ACCESS,

																						0,

																						0,

																						nDataSize);

										m_pSharedMemory[1] = (BYTE*)MapViewOfFile(	m_hSharedMemory[1],

																						FILE_MAP_ALL_ACCESS,

																						0,

																						0,

																						nDataSize);

										if (m_pSharedMemory[0] && m_pSharedMemory[1])

										{

											// Move the pointer a little further so that it does not point to

											// the size tag, but to the address of the data that we want to share.

											m_pSharedMemory[0] += sizeof(int);

											m_pSharedMemory[1] += sizeof(int);



											// The following events make sure that data can only

											// be read when data was written and vise versa.

											char sDataWrit0		[MAX_PATH];

											char sDataWrit1		[MAX_PATH];

											char sDataRead0		[MAX_PATH];

											char sDataRead1		[MAX_PATH];

											strcpy(sDataWrit0	, sName);

											strcpy(sDataWrit1	, sName);

											strcpy(sDataRead0	, sName);

											strcpy(sDataRead1	, sName);

											strcat(sDataWrit0	, "DataWrit0");

											strcat(sDataWrit1	, "DataWrit1");

											strcat(sDataRead0	, "DataRead0");

											strcat(sDataRead1	, "DataRead1");

											m_hDataWrit[0]	= CreateEvent(NULL, FALSE, FALSE,	sDataWrit0);

											m_hDataWrit[1]	= CreateEvent(NULL, FALSE, FALSE,	sDataWrit1);

											m_hDataRead[0]	= CreateEvent(NULL, FALSE, TRUE,	sDataRead0);

											m_hDataRead[1]	= CreateEvent(NULL, FALSE, TRUE,	sDataRead1);

											if (m_hDataWrit[0] && m_hDataWrit[1] && m_hDataRead[0] && m_hDataRead[1])

											{

												m_hSecondInstanceAvailable = CreateEvent(NULL, FALSE, FALSE, sName);

												if (m_hSecondInstanceAvailable)

												{

													if (m_nInstanceID == 0)

													{

														// We are the first instance, wait for the second instance

														// to come this far, then we can assume that the connection

														// is fully open.

														if (WaitForSingleObject(m_hSecondInstanceAvailable, nTimeOut) == WAIT_OBJECT_0)

														{

															CloseHandle(m_hSecondInstanceAvailable);

															ResetEvent(m_hClosed);

															m_hQueueMutex	= CreateMutex(NULL, FALSE, NULL);

															m_hDataInQueue	= CreateEvent(NULL, FALSE, FALSE, NULL);

															m_hQueueThread	= (HANDLE)_beginthread(QueueThread, 0, this);

															return true;

														}

													}

													else if (m_nInstanceID == 1)

													{

														// We are the second instance, signal the other instance that

														// we have come this far.

														// Immediately wait 0 seconds for the event, if it is still signaled

														// we know that the other instance was not waiting, the connection

														// has failed.

														SetEvent(m_hSecondInstanceAvailable);

														if (WaitForSingleObject(m_hSecondInstanceAvailable, 0) == WAIT_TIMEOUT)

														{

															CloseHandle(m_hSecondInstanceAvailable);

															ResetEvent(m_hClosed);

															m_hQueueMutex	= CreateMutex(NULL, FALSE, NULL);

															m_hDataInQueue	= CreateEvent(NULL, FALSE, FALSE, NULL);

															m_hQueueThread	= (HANDLE)_beginthread(QueueThread, 0, this);

															return true;

														}

													}

													CloseHandle(m_hSecondInstanceAvailable);

												}

												else

												{

													// We could not create the required event.

												}

											}

											else

											{

												// We could not create any event handles.

											}

											UnmapViewOfFile(m_pSharedMemory[0]);

											UnmapViewOfFile(m_pSharedMemory[1]);

										}

										else

										{

											// We could not get a pointer to the actual data.

										}

									}

									else

									{

										// The datasize of the already allocated memory, and the size of this

										// instance do not match.

									}

									UnmapViewOfFile(m_pSize);

								}

								else

								{

									// We could not map to the integer that contains the size of the memory block.

								}

								CloseHandle(m_hSharedMemory[0]);

								CloseHandle(m_hSharedMemory[1]);

							}

							else

							{

								// The memory handles could not be created.

							}

						}

						else

						{

							// There was no mutex available, this can mean that there are

							// already two instances of this object with the same name

							// in use on this system.

						}

						CloseHandle(m_hSharedMemoryMutex[0]);

						CloseHandle(m_hSharedMemoryMutex[1]);

					}

					else

					{

						// The mutexes could not be created.

					}

				}

				else

				{

					// The datasize is not > 0.

				}

			}

			else

			{

				// The name of the shared memory is not valid, or the datasize is not larger than 0.

			}

		}

		else

		{

			// This instance is already open.

		}

		return false;

	};

	void Close()

	{

		if (WaitForSingleObject(m_hClosed, 0) == WAIT_TIMEOUT)

		{

			// Indicate that this instance is closed

			SetEvent(m_hClosed);



			// Release your own mutex. This will auitomatically signal

			// the other instance of this class that this instance broke

			// the connection.

			ReleaseMutex(m_hSharedMemoryMutex[m_nInstanceID]);



			// The writequeue may still contain elements, empty

			// it.

			EmptyWriteQueue();



			WaitForSingleObject(m_hQueueThread, INFINITE);

			CloseHandle(m_hQueueMutex);

			CloseHandle(m_hDataInQueue);

			m_hQueueMutex	= NULL;

			m_hDataInQueue	= NULL;



			// Cleanup some stuff.

			CloseHandle(m_hDataWrit[0]);

			CloseHandle(m_hDataWrit[1]);

			CloseHandle(m_hDataRead[0]);

			CloseHandle(m_hDataRead[1]);

			m_hDataWrit[0] = NULL;

			m_hDataWrit[1] = NULL;

			m_hDataRead[0] = NULL;

			m_hDataRead[1] = NULL;



			UnmapViewOfFile(m_pSize);



			m_pSharedMemory[0] -= sizeof(int);

			m_pSharedMemory[1] -= sizeof(int);

			UnmapViewOfFile(m_pSharedMemory[0]);

			UnmapViewOfFile(m_pSharedMemory[1]);

			

			CloseHandle(m_hSharedMemory[0]);

			CloseHandle(m_hSharedMemory[1]);



			CloseHandle(m_hSharedMemoryMutex[0]);

			CloseHandle(m_hSharedMemoryMutex[1]);



		}

	};

	int Write(void *pData, int nDataSize, DWORD dwTimeOut)

	{

		// The 'Write' and 'WriteToQueue' functions can be used promiscously.



		// This function writes to the shared memory pool, it can only write

		// to that pool if existing data in the pool has been read by the

		// other instance of this class.

		// If this function returns MEM_ERROR_OTHERPARTY, the calling

		// process should close the connection and re-open it to create a new

		// valid connection.

		HANDLE	hWait[3];

		hWait[0]	= m_hClosed;

		hWait[1]	= m_hSharedMemoryMutex[m_nOtherInstanceID];

		hWait[2]	= m_hDataRead[m_nOtherInstanceID];

		DWORD	dwWaitResult = WaitForMultipleObjects(3, hWait, FALSE, dwTimeOut);

		switch(dwWaitResult)

		{

		case WAIT_OBJECT_0 + 2:

			if (nDataSize > *m_pSize)

				return MEM_ERROR_DATASIZE;

			// Data was read from the shared memory pool, write new data

			// and notify any listener that new data was written.

			memcpy(m_pSharedMemory[m_nOtherInstanceID], pData, nDataSize);

			SetEvent(m_hDataWrit[m_nOtherInstanceID]);

			return MEM_SUCCESS;

		case WAIT_OBJECT_0:

			// The close function of this instance was called.

			return MEM_ERROR_CLOSED;

		case WAIT_OBJECT_0 + 1:

			// The other instance closed.

			// Since we locked the mutex by waiting for it, we have to release

			// it again.

			ReleaseMutex(m_hSharedMemoryMutex[m_nOtherInstanceID]);

			return MEM_ERROR_OTHERPARTY;

		case WAIT_ABANDONED_0 + 1:

			// The other instance left without a trace, this means probably that

			// it crashed.

			// Since we locked the mutex by waiting for it, we have to release

			// it again.

			ReleaseMutex(m_hSharedMemoryMutex[m_nOtherInstanceID]);

			return MEM_ERROR_OTHERPARTY;

		case WAIT_FAILED:

			if (!m_hDataRead[m_nOtherInstanceID])

				return MEM_ERROR_CLOSED;

			// I don't know wat happened, you should call 'GetLastError()'.

			return MEM_ERROR_UNKNOWN;

		case WAIT_TIMEOUT:

			// There was a timeout, the other party has not yet read previous data.

			return MEM_ERROR_TIMEOUT;

		}

		return MEM_ERROR_UNKNOWN;

	}

	int WriteToQueue(void *pData, int nDataSize)

	{

		// The 'Write' and 'WriteToQueue' functions can be used promiscously.



		// This function is somewhat the same as the previous function, however,

		// this function is non-blocking. As long as the connection is valid this

		// function can write new data into a queue. The queue is read by a thread

		// that calls the previous 'Write' function.

		HANDLE	hWait[3];

		hWait[0]	= m_hClosed;

		hWait[1]	= m_hSharedMemoryMutex[m_nOtherInstanceID];

		hWait[2]	= m_hQueueMutex;

		switch (WaitForMultipleObjects(3, hWait, FALSE, INFINITE))

		{

		case WAIT_OBJECT_0:

			return MEM_ERROR_CLOSED;

		case WAIT_OBJECT_0 + 2:

			{

				if (nDataSize > *m_pSize)

					return MEM_ERROR_DATASIZE;

				CWriteQueue *pNew = new CWriteQueue(*m_pSize);

				memcpy(pNew->pData, pData, *m_pSize);



				if (!m_pFirst)

					m_pFirst = pNew;

				else

				{

					CWriteQueue *pCurrent = m_pFirst;

					while (pCurrent->pNext)

						pCurrent = pCurrent->pNext;

					pCurrent->pNext = pNew;

				}



				SetEvent(m_hDataInQueue);

				ReleaseMutex(m_hQueueMutex);

			}

			return MEM_SUCCESS;

		case WAIT_OBJECT_0 + 1:

			// The other instance closed.

			// Since we locked the mutex by waiting for it, we have to release

			// it again.

			ReleaseMutex(m_hSharedMemoryMutex[m_nOtherInstanceID]);

			return MEM_ERROR_OTHERPARTY;

		case WAIT_ABANDONED_0 + 1:

			// The other instance left without a trace, this means probably that

			// it crashed.

			// Since we locked the mutex by waiting for it, we have to release

			// it again.

			ReleaseMutex(m_hSharedMemoryMutex[m_nOtherInstanceID]);

			return MEM_ERROR_OTHERPARTY;

		case WAIT_FAILED:

			// This can happen when the connection was not opened yet.

			// It is caused by an invalid or NULL handle.

			if (!m_hQueueMutex)

				return MEM_ERROR_CLOSED;

			// This must never happen.

			return MEM_ERROR_UNKNOWN;

		}

		return MEM_ERROR_UNKNOWN;

	}

	int Read(void *pData, int nDataSize, DWORD dwTimeOut)

	{

		// This function reads from the shared memory pool, it can

		// only read data when data was written to the pool.

		// It is always a blocking function.



		// It reads data that was written to the shared memory pool by

		// the 'Write' or 'WriteToQueue' functions.

		HANDLE	hWait[3];

		hWait[0]	= m_hDataWrit[m_nInstanceID];

		hWait[1]	= m_hClosed;

		hWait[2]	= m_hSharedMemoryMutex[m_nOtherInstanceID];

		DWORD	dwWaitResult = WaitForMultipleObjects(3, hWait, FALSE, dwTimeOut);

		switch(dwWaitResult)

		{

		case WAIT_OBJECT_0:

			// This happens when data is written into the shared memory pool.

			// It indicates that the data can be copied into a memory

			// buffer.

			if (nDataSize > *m_pSize)

				return MEM_ERROR_DATASIZE;

			memcpy(pData, m_pSharedMemory[m_nInstanceID], nDataSize);

			SetEvent(m_hDataRead[m_nInstanceID]);

			return MEM_SUCCESS;

		case WAIT_OBJECT_0 + 1:

			// This happens when no connection was made yet, or this

			// instance was closed.

			return MEM_ERROR_CLOSED;

		case WAIT_OBJECT_0 + 2:

			// This happens when the other party closes its connection.

			ReleaseMutex(m_hSharedMemoryMutex[m_nOtherInstanceID]);

			return MEM_ERROR_OTHERPARTY;

		case WAIT_ABANDONED_0 + 2:

			// This happens when the other party gracefully closes its connection.

			// This can be caused by an unexpected termination of the host

			// process of the other instance.

			ReleaseMutex(m_hSharedMemoryMutex[m_nOtherInstanceID]);

			return MEM_ERROR_OTHERPARTY;

		case WAIT_FAILED:

			// This can happen when the connection was not opened yet.

			// It is caused by an invalid or NULL handle.

			if (!m_hDataWrit[m_nInstanceID])

				return MEM_ERROR_CLOSED;

			return MEM_ERROR_UNKNOWN;

		case WAIT_TIMEOUT:

			// This indicates that the maximum wait time (dwTimeOut) has passed.

			return MEM_ERROR_TIMEOUT;

		}

		return MEM_ERROR_UNKNOWN;

	}

private:

	void EmptyWriteQueue()

	{

		// This private function avoids memory leaking of items in the send-queue.

		while (m_pFirst && WaitForSingleObject(m_hQueueMutex, INFINITE) == WAIT_OBJECT_0)

		{

			if (m_pFirst)

			{

				// First get the first element of the queue

				CWriteQueue *pQueue = m_pFirst;

				m_pFirst = pQueue->pNext;

				delete pQueue;

			}

			ReleaseMutex(m_hQueueMutex);

		}

	}

	static void QueueThread(void *pArg)

	{

		// This thread writes every packet that enteres the queue to the shared memory pool.

		// It ensures that the 'WriteToQueue' function is nonblocking.

		// The queue access is mutexed to avoid simultaneous access to the queue by

		// this thread and the 'WriteToQueue' function.

		CSharedMemory	*pThis = (CSharedMemory*)pArg;

		HANDLE hWait[2] = {pThis->m_hClosed, pThis->m_hDataInQueue};

		bool bQuit = false;

		while (!bQuit)

		{

			switch (WaitForMultipleObjects(2, hWait, FALSE, INFINITE))

			{

			case WAIT_OBJECT_0 + 1:

				{

					BYTE *pData = NULL;

					while (pThis->m_pFirst && WaitForSingleObject(pThis->m_hQueueMutex, INFINITE) == WAIT_OBJECT_0)

					{

						if (pThis->m_pFirst)

						{

							// First get the first element of the queue

							CWriteQueue *pQueue = pThis->m_pFirst;

							pData = new BYTE[*pThis->m_pSize];

							memcpy(pData, pThis->m_pFirst->pData, *pThis->m_pSize);

							pThis->m_pFirst = pQueue->pNext;

							delete pQueue;

							ReleaseMutex(pThis->m_hQueueMutex);

				

							pThis->Write(pData, *pThis->m_pSize, INFINITE);

							delete [] pData;

						}

						else

							ReleaseMutex(pThis->m_hQueueMutex);

					}

				}

				break;

			case WAIT_OBJECT_0:

				bQuit = true;

				break;

			}

		}

	}

private:

	// We will use two shared memory pools to create a transparant memory 'pipe'.

	// One pool will be used as destination for one instance, and source for the other

	// instance, the other will be used the other way around.

	// The two mutexes will indicate which instance is already available.

	HANDLE			m_hSharedMemoryMutex[2];



	int				m_nInstanceID;

	int				m_nOtherInstanceID;



	HANDLE			m_hSharedMemory[2];



	BYTE*			m_pSharedMemory[2];



	int*			m_pSize;

	HANDLE			m_hClosed;			// This handle indicates wether this instance

										// is open or closed.

	HANDLE			m_hDataWrit[2];

	HANDLE			m_hDataRead[2];



	HANDLE			m_hSecondInstanceAvailable;



	// Queue stuff

	HANDLE			m_hQueueThread;

	HANDLE			m_hDataInQueue;

	CWriteQueue		*m_pFirst;

	HANDLE			m_hQueueMutex;

};



#endif // !defined(AFX_SHAREDMEMORY_H__86467BA6_5AFA_11D3_863D_00A0244A9CA7__INCLUDED_)