《C++多线程编程实战》——2.5　进程间通信（IPC）

2.5　进程间通信（IPC）

进程之间的通信非常重要。虽然操作系统提供了进程间通信的机制，但是在介绍这些机制之前，我们先来考虑一些与之相关的问题。如果航空预定系统中有两个进程在同时销售本次航班的最后一张机票，怎么办？这里要解决两个问题。第1个问题是，一个座位不可能卖两次。第2个问题是一个依赖性问题：如果进程A生成的某些数据是进程B需要读取的（如，打印这些数据），那么进程B在进程A准备好这些数据之前必须一直等待。进程和线程的不同在于，线程共享同一个地址空间，而进程拥有单独的地址空间。因此，用线程解决第1个问题比较容易。至于第2个问题，线程也同样能解决。所以，理解同步机制非常重要。

在讨论IPC之前，我们先来考虑一个简单的例子：CD刻录机。当一个进程要刻录一些内容时，会在特定的刻录缓冲区中设置文件句柄（我们立刻要刻录更多的文件）。另一个负责刻录的进程，检查待刻录的文件是否存在，如果存在，该进程将刻录文件，然后从缓冲区中移除该文件的句柄。假设刻录缓冲区有足够多的索引，分别编号为I0、I1、I2等，每个索引都能储存若干文件句柄。再假设有两个共享变量：p_next和p_free，前者指向下一个待刻录的缓冲区索引，后者指向缓冲区中的下一个空闲索引。所有进程都要使用这两个变量。在某一时刻，索引I0和I2为空（即文件已经刻录完毕），I3和I5已经加入缓冲。同时，进程5和进程6决定把文件句柄加入队列准备刻录文件。这一状况如图2.7所示。

图2.7

首先，进程5读取p_free，把它的值I6储存在自己的局部变量f_slot中。接着，发生了一个时钟中断，CPU认为进程5运行得太久了，决定转而执行进程6。然后，进程6也读取p_free，同样也把I6储存在自己的局部变量f_slot中。此时，两个进程都认为下一个可用的索引是I6。进程6现在继续运行，它把待拷贝文件的句柄储存在索引I6中，并更新p_free为I7。然后，系统让进程6睡眠。现在，进程5从原来暂停的地方再次开始运行。它查看自己的f_slot，发现可用的索引是I6，于是把自己待拷贝文件的句柄写到索引I6上，擦除了进程6刚写入的文件句柄。然后，进程5计算f_slot+1得I7，就把p_free设置为I7。现在，刻录缓冲区内部保持一致，所以刻录进程并未出现任何错误。但是，进程6再也接收不到任何输出。

进程6将被无限闲置，等待着再也不会有的输出。像这样两个或更多实体读取或写入某共享数据的情况，最终的结果取决于进程的执行顺序（即何时执行哪一个进程），这叫做竞态条件（race condition）。

如何避免竞态条件？大部分解决方案都涉及共享内存、共享文件以及避免不同的进程同时读写共享数据。换句话说，我们需要互斥（mutual exclusion）或一种能提供独占访问共享对象的机制（无论它是共享变量、共享文件还是其他对象）。当进程6开始使用进程5刚用完的一个共享对象时，就会发生糟糕的事情。

程序中能被访问共享内存的部分叫做临界区（critical section）。为了避免竞态条件，必须确保一次只能有一个进程进入临界区。这种方法虽然可以避免竞态条件，但是在执行并行进程时会影响效率，毕竟并行的目的是正确且高效地合作。要使用共享数据，必须处理好下面4个条件：

不允许同时有两个进程在临界区内；
不得对CPU的速度或数量进行假设；
在临界区外运行的进程不得阻碍其他进程；
不得有任何进程处于永远等待进入临界区。
以上所述如图2.8所示。过程A在T1时进入临界区。稍后，进程B在T2尝试进入其临界区，但是失败。因为另一个进程已经在临界区中，同一时间内只允许一个进程在临界区内。在T3之前，进程B必须被临时挂起。在进程A离开临界区时，进程B便可立即进入。最终，进程B离开临界区（T4时），又回到没有进程进入临界区的状态。

图2.8

下面是一个进程间通信的程序示例。我们创建的这个程序一开始就有两个进程，它们要在一个普通窗口中完成绘制矩形的任务。从某种程度上看，这两个进程需要相互通信，即当一个进程正在画矩形时，另一个进程要等待。

准备就绪
确定安装并运行了Visual Studio。

操作步骤
1．创建一个新的默认C++控制台应用程序，命名为IPCDemo。

2．右键单击【解决方案资源管理器】，并选择【添加】-【新建项目】。选择C++【Win32控制台应用程序】，添加一个新的默认C++控制台应用程序，命名为IPCWorker。

3．在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;
}```
4． 打开`IPCDemo.cpp`，并输入下面的代码：

include "stdafx.h"

include

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;
}`
示例分析
这次演示的示例有点难。我们需要两个单独的线程，所以在同一个解决方案中创建了两个项目。

为了简化这个示例，我们在主应用程序IPCDemo中创建了两个进程IPCDemo将在应用程序窗口中绘制一个区域。如果没有正确的通信和进程同步，就会发生多路访问共享资源的情况。考虑到操作系统会在进程间快速切换，而且大部分PC都有多核CPU，这很可能会导致两个进程同时画一个区域，即多个进程同时访问未保护的区域。先来看IPCWorker，这个名称的意思是，需要进程为我们处理一些工作。

我们使用了一个映射对象（即，内存中为进程分配读取或写入的区域）。IPCWorker或简称Worker，要请求获得一个已命名的互斥量。如果获得互斥量，该进程就能处理并获取一个指向内存区域（文件映射）的指针，信息将储存在这个区域。必须获得互斥量，才能进行独占访问。进程在WaitForSingleObject返回后获得互斥量。请看下面的语句：

HANDLE hMutex = OpenMutex( MUTEX_ALL_ACCESS, FALSE, SYNCHRONIZING_MUTEX_NAME );```
我们要为互斥量（`hMutex`）分配一个句柄，调用`OpenMutex Win32 API`获得该已命名互斥量的句柄（如果有互斥量的话）。请看下面的语句：
`
WaitForSingleObject( hMutex, INFINITE );`
执行完这条语句后，当WaitForSingleObjectAPI返回时继续执行。

pCommObject = ( PCOMMUNICATIONOBJECT )
　 MapViewOfFile( hMapping, FILE_MAP_READ, 0, 0, sizeof( COMMUNICATIONOBJECT ) );`
调用MapViewOfFileWin32 API获得指向文件映射对象的句柄（指针）。现在，进程可以从共享内存对象中读取并获得所需的信息了。该进程要读取bExitLoop变量才能获悉是否继续执行。然后，该进程要读取待绘制区域窗口的句柄（hWnd）。最后，还需要lSleepTimeout变量记录进程睡眠多久。我们故意添加了sleep时间，因为进程间切换太快根本注意不到。
`
ReleaseMutex( hMutex );`
调用ReleaseMutex Win32 API释放互斥量的所有权，让其他进程可以获得互斥量，继续执行其他任务。分析完IPCWorker，我们来看IPCDemo项目。该项目定义了_tagCOMMUNICATIONOBJECT结构，用于整个文件映射过程中对象之间的通信。

文件映射（file mapping）是把文件的内容与一个进程的一部分虚拟地址空间相关联。操作系统创建一个文件映射对象（也叫做区域对象[section object]）来维护这种关联。文件视图（file view）是进程用于访问文件内容的虚拟地址空间部分。有了文件映射，进程不仅能使用随机I/O和顺序I/O，而且无需把整个文件映射到内存中就能高效地使用大型数据文件（如，数据库）。多个进程还可以用已映射的内存文件来共享数据。详见MSDN（http://msdn.microsoft.com/en-us/library/windows/desktop/aa366883%28v=vs.85%29.aspx）。

正是因为IPCDemo在运行Worker进程之前就创建了文件映射，所以从Worker进程询问文件映射之前不用检查文件映射是否存在。IPCDemo创建并初始化应用程序窗口和待绘制区域后，创建了一个已命名的互斥量和文件映射。然后，用不同的命令行参数（用以区别）创建不同的进程。

WndProc例程处理WM_COMMAND和WM_DESTROY消息。当我们需要通知应用程序安全地关闭时，WM_COMMAND触发按钮按下事件，而WM_DESTROY则释放用过的文件映射，并向主线程消息队列寄送关闭消息：
`
PostQuitMessage( 0 );`
更多讨论
文件映射要与常驻磁盘的文件和常驻内存的文件视图一起运作。用内存的文件视图比用硬盘驱动的读写速度快。如果要用共享对象在进程之间处理一些简单的事情，选用文件映射是很好的编程习惯。如果把CreateFileMapping API的第1个参数设置为-1，磁盘中就不会有文件存在：

CreateFileMapping( ( HANDLE ) -1, NULL, PAGE_READWRITE, 0,
　　 sizeof( COMMUNICATIONOBJECT ), COMMUNICATION_OBJECT_NAME );```
这真是再好不过了，因为我们正打算使用一部分内存，这样更快，而且也够用了。

调用`IPCWorker`进程时要注意。像下面这样设置`CreateProcess`，以供调试：

bSuccess = CreateProcess( TEXT( "..\Debug\IPCWorker.exe" ),
　　 TEXT( "red" ), NULL, NULL, FALSE, 0, NULL, NULL,
　　 &startupInfoRed, &processInformationRed );``
Visual Studio在调试模式中只会从项目文件夹开始启动，不会从程序的exe文件夹开始启动。而且，Visual Studio默认把所有的Win32项目都输出到同一个文件夹中。所以，在文件路径中，我们必须从项目文件夹返回上一级（文件夹），然后找到Debug文件夹，整个项目的输出（exe）就在这个文件夹中。如果不想让VS这样启动exe，就必须改变CreateProcess调用的路径，或者添加通过命令行或其他类似方法访问文件路径的功能。

时间： 2024-07-31 14:35:06

《C++多线程编程实战》——2.5　进程间通信（IPC）

2.5　进程间通信（IPC）

include "stdafx.h"

include

include

define COMMUNICATION_OBJECT_NAME TEXT("_ FILE_MAPPING _")

define SYNCHRONIZING_MUTEX_NAME TEXT( "_ TEST_MUTEX _" )

define WINDOW_CLASS_NAME TEXT( "_ TMPWNDCLASS _" )

define BUTTON_CLOSE 100