c++进程间通信方式——共享内存（文件映射）

本文项目源码：github：https://github.com/2012Netsky/IPC/tree/IPC

---

绪论

共享存储SharedMemory：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。

---

一、原理

共享内存允许两个或多个进程共享一个给定的存储区，这一段存储区可以被两个或两个以上的进程映射至自身的地址空间中，一个进程写入共享内存的信息，可以被其他使用这个共享内存的进程，通过一个简单的内存读取错做读出，从而实现了进程间的通信。采用共享内存进行通信的一个主要好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝，对于像管道和消息队里等通信方式，则需要再内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次：一次从输入文件到共享内存区，另一次从共享内存到输出文件。

一般而言，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时在重新建立共享内存区域；而是保持共享区域，直到通信完毕为止，这样，数据内容一直保存在共享内存中，并没有写回文件。共享内存中的内容往往是在解除映射时才写回文件，因此，采用共享内存的通信方式效率非常高。

共享内存有两种实现方式：1、内存映射 2、共享内存机制

二、子进程

代码如下（示例）：
IPCWorker.cpp

#include "stdafx.h"
#include <Windows.h>

#define COMMUNICATION_OBJECT_NAME	TEXT("__FILE_MAPPING__")
#define SYNCHRONIZING_MUTEX_NAME	TEXT( "__TEST_MUTEX__" )

typedef struct _tagCOMMUNICATIONOBJECT
{
	HWND	hWndClient;
	BOOL	bExitLoop;
	LONG	lSleepTimeout;
} COMMUNICATIONOBJECT, *PCOMMUNICATIONOBJECT;

int _tmain(int argc, _TCHAR* argv[])
{
	HBRUSH hBrush = NULL;

	if (_tcscmp(TEXT("blue"), argv[0]) == 0)
	{
		hBrush = CreateSolidBrush(RGB(0, 0, 255));
	}
	else
	{
		hBrush = CreateSolidBrush(RGB(255, 0, 0));
	}

	HWND hWnd = NULL;
	HDC hDC = NULL;
	RECT rectClient = { 0 };
	LONG lWaitTimeout = 0;
	HANDLE hMapping = NULL;
	PCOMMUNICATIONOBJECT pCommObject = NULL;
	BOOL bContinueLoop = TRUE;

	HANDLE hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, SYNCHRONIZING_MUTEX_NAME);
	hMapping = OpenFileMapping(FILE_MAP_READ, FALSE, COMMUNICATION_OBJECT_NAME);

	if (hMapping)
	{
		while (bContinueLoop)
		{
			WaitForSingleObject(hMutex, INFINITE);
			pCommObject = (PCOMMUNICATIONOBJECT) MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, sizeof(COMMUNICATIONOBJECT));

			if (pCommObject)
			{
				bContinueLoop = !pCommObject->bExitLoop;
				hWnd = pCommObject->hWndClient;
				lWaitTimeout = pCommObject->lSleepTimeout;
				UnmapViewOfFile(pCommObject);
				hDC = GetDC(hWnd);
				if (GetClientRect(hWnd, &rectClient))
				{
					FillRect(hDC, &rectClient, hBrush);
				}
				ReleaseDC(hWnd, hDC);
				Sleep(lWaitTimeout);
			}
			ReleaseMutex(hMutex);
		}
	}
	CloseHandle(hMapping);
	CloseHandle(hMutex);
	DeleteObject(hBrush);

	return 0;
}

三、主进程

代码如下（示例）：
IPCDemo.cpp

#include "stdafx.h"
#include <Windows.h>
#include <iostream>

using namespace std;

#define COMMUNICATION_OBJECT_NAME	TEXT("__FILE_MAPPING__")
#define SYNCHRONIZING_MUTEX_NAME		TEXT( "__TEST_MUTEX__" )
#define WINDOW_CLASS_NAME				TEXT( "__TMPWNDCLASS__" )
#define BUTTON_CLOSE					100

typedef struct _tagCOMMUNICATIONOBJECT
{
	HWND	hWndClient;
	BOOL	bExitLoop;
	LONG	lSleepTimeout;
} COMMUNICATIONOBJECT, *PCOMMUNICATIONOBJECT;

LRESULT CALLBACK WndProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
HWND InitializeWnd();
PCOMMUNICATIONOBJECT pCommObject = NULL;
HANDLE hMapping = NULL;

int _tmain(int argc, _TCHAR* argv[])
{
	cout << "Interprocess communication demo." << endl;
	HWND hWnd = InitializeWnd();
	if (!hWnd)
	{
		cout << "Cannot create window!" << endl << "Error:\t" << GetLastError() << endl;
		return 1;
	}
	HANDLE hMutex = CreateMutex(NULL, FALSE, SYNCHRONIZING_MUTEX_NAME);
	if (!hMutex)
	{
		cout << "Cannot create mutex!" << endl << "Error:\t" << GetLastError() << endl;
		return 1;
	}
	hMapping = CreateFileMapping((HANDLE)-1, NULL, PAGE_READWRITE, 0, sizeof(COMMUNICATIONOBJECT), COMMUNICATION_OBJECT_NAME);
	if (!hMapping)
	{
		cout << "Cannot create mapping object!" << endl << "Error:\t" << GetLastError() << endl;
		return 1;
	}
	pCommObject = (PCOMMUNICATIONOBJECT) MapViewOfFile(hMapping, FILE_MAP_WRITE, 0, 0, 0);
	if (pCommObject)
	{
		pCommObject->bExitLoop = FALSE;
		pCommObject->hWndClient = hWnd;
		pCommObject->lSleepTimeout = 250;
		UnmapViewOfFile(pCommObject);
	}

	STARTUPINFO startupInfoRed = { 0 };
	PROCESS_INFORMATION processInformationRed = { 0 };
	STARTUPINFO startupInfoBlue = { 0 };
	PROCESS_INFORMATION processInformationBlue = { 0 };

	BOOL bSuccess = CreateProcess( TEXT("..\\Debug\\IPCWorker.exe"), TEXT("red"), NULL, NULL, FALSE, 0, NULL, NULL, &startupInfoRed, &processInformationRed);
	if (!bSuccess)
	{
		cout << "Cannot create process red!" << endl << "Error:\t" << GetLastError() << endl;
		return 1;
	}
	bSuccess = CreateProcess( TEXT("..\\Debug\\IPCWorker.exe"), TEXT("blue"), NULL, NULL, FALSE, 0, NULL, NULL, &startupInfoBlue, &processInformationBlue);
	if (!bSuccess)
	{
		cout << "Cannot create process blue!" << endl << "Error:\t" << GetLastError() << endl;
		return 1;
	}
	MSG msg = { 0 };
	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	UnregisterClass(WINDOW_CLASS_NAME, GetModuleHandle(NULL));
	CloseHandle(hMapping);
	CloseHandle(hMutex);
	cout << "End program." << endl;
	return 0;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
		case WM_COMMAND:
		{
			switch (LOWORD(wParam))
			{
				case BUTTON_CLOSE:
				{
					PostMessage(hWnd, WM_CLOSE, 0, 0);

					break;
				}
			}

			break;
		}
		case WM_DESTROY:
		{
			pCommObject = (PCOMMUNICATIONOBJECT) MapViewOfFile(hMapping, FILE_MAP_WRITE, 0, 0, 0);
			if (pCommObject)
			{
				pCommObject->bExitLoop = TRUE;
				UnmapViewOfFile(pCommObject);
			}

			PostQuitMessage(0);
			break;
		}
		default:
		{
			return DefWindowProc(hWnd, uMsg, wParam, lParam);
		}
	}
	return 0;
}

HWND InitializeWnd()
{
	WNDCLASSEX wndEx;
	wndEx.cbSize = sizeof(WNDCLASSEX);
	wndEx.style = CS_HREDRAW | CS_VREDRAW;
	wndEx.lpfnWndProc = WndProc;
	wndEx.cbClsExtra = 0;
	wndEx.cbWndExtra = 0;
	wndEx.hInstance = GetModuleHandle(NULL);
	wndEx.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
	wndEx.lpszMenuName = NULL;
	wndEx.lpszClassName = WINDOW_CLASS_NAME;
	wndEx.hCursor = LoadCursor(NULL, IDC_ARROW);
	wndEx.hIcon = LoadIcon(wndEx.hInstance, MAKEINTRESOURCE(IDI_APPLICATION));
	wndEx.hIconSm = LoadIcon(wndEx.hInstance, MAKEINTRESOURCE(IDI_APPLICATION));
	if (!RegisterClassEx(&wndEx))
	{
		return NULL;
	}
	HWND hWnd = CreateWindow(wndEx.lpszClassName, TEXT("Interprocess communication Demo"), 
		WS_OVERLAPPEDWINDOW, 200, 200, 400, 300, NULL, NULL, wndEx.hInstance, NULL);
	if (!hWnd)
	{
		return NULL;
	}
	HWND hButton = CreateWindow(TEXT("BUTTON"), TEXT("Close"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON | WS_TABSTOP, 
		275, 225, 100, 25, hWnd, (HMENU)BUTTON_CLOSE, wndEx.hInstance, NULL);
	HWND hStatic = CreateWindow(TEXT("STATIC"), TEXT(""), WS_CHILD | WS_VISIBLE, 10, 10, 365, 205, hWnd, NULL, wndEx.hInstance, NULL);
	ShowWindow(hWnd, SW_SHOW);
	UpdateWindow(hWnd);
	return hStatic;
}

总结

共享存储SharedMemory：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。