Windows系統編程之進程間通訊

時間 2019-11-13

原文原文鏈接

Windows系統編程之進程間通訊
做者：北極星2003
來源：看雪論壇（www.pediy.com）
Windows 的IPC（進程間通訊）機制主要是異步管道和命名管道。（至於其餘的IPC方式，例如內存映射、郵槽等這裏就不介紹了）
管道（pipe）是用於進程間通訊的共享內存區域。建立管道的進程稱爲管道服務器，而鏈接到這個管道的進程稱爲管道客戶端。一個進程向管道寫入信息，而另一個進程從管道讀取信息。
異步管道是基於字符和半雙工的（即單向），通常用於程序輸入輸出的重定向；命名管道則強大地多，它們是面向消息和全雙工的，同時還容許網絡通訊，用於建立客戶端/服務器系統。
1、異步管道(實現比較簡單，直接經過實例來說解)
實驗目標：當前有sample.cpp, sample.exe, sample.in這三個文件，sample.exe爲sample.cpp的執行程序，sample.cpp只是一個簡單的程序示例（簡單求和），以下：php

代碼:

[cpp] view plain copy

#include <iostream.h>
int main()
{
int a, b ;
while ( cin >> a >> b && ( a || b ) )
cout << a + b << endl ;
return 0;
}

Sample.in文件是輸入文件，內容：
32 433
542 657
0 0
要求根據sample.exe和它的輸入數據，把輸出數據重定向到sample.out
流程分析：實際這個實驗中包含兩個部分，把輸入數據重定向到sample.exe 和把輸出數據重定向到sample.out。在命令行下能夠很簡單的實現這個功能「sample <sample.in >sample.out」，這個命令也是利用管道特性實現的，如今咱們就根據異步管道的實現原理本身來實現這個功能。
管道是基於半雙工（單向）的，這裏有兩個重定向的過程，顯然須要建立兩個管道，下面給出流程圖：

異步管道實現的流程圖說明：
1）。父進程是咱們須要實現的，其中須要建立管道A，管道B，和子進程，整個實現流程分爲4個操做。
2）。管道A：輸入管道
3）。管道B：輸出管道
4）。操做A：把輸入文件sample.in的數據寫入輸入管道（管道A）
5）。操做B：子進程從輸入管道中讀取數據，做爲該進程的加工原料。一般，程序的輸入數據由標準的輸入設備輸入，這裏實現輸入重定向，即把輸入管道做爲輸入設備。
6）。操做C：子進程把加工後的成品（輸出數據）輸出到輸出管道。一般，程序的輸出數據會輸出到標準的輸出設備，通常爲屏幕，這裏實現輸出重定向，即把輸出管道做爲輸出設備。
7）。操做D：把輸出管道的數據寫入輸出文件
須要注意的是，管道的本質只是一個共享的內存區域。這個實驗中，管道區域處於父進程的地址空間中，父進程的做用是提供環境和資源，並協調子進程進行加工。
程序源碼：

代碼:

[cpp] view plain copy

#include <windows.h>
#include <iostream.h>
const int BUFSIZE = 4096 ;
HANDLE hChildStdinRd, hChildStdinWr, hChildStdinWrDup,
hChildStdoutRd,hChildStdoutWr,hChildStdoutRdDup,
hSaveStdin, hSaveStdout;
BOOL CreateChildProcess(LPTSTR);
VOID WriteToPipe(LPTSTR);
VOID ReadFromPipe(LPTSTR);
VOID ErrorExit(LPTSTR);
VOID ErrMsg(LPTSTR, BOOL);
void main( int argc, char *argv[] )
{
// 處理輸入參數
if ( argc != 4 )
return ;
// 分別用來保存命令行，輸入文件名（CPP/C），輸出文件名（保存編譯信息）
LPTSTR lpProgram = new char[ strlen(argv[1]) ] ;
strcpy ( lpProgram, argv[1] ) ;
LPTSTR lpInputFile = new char[ strlen(argv[2]) ];
strcpy ( lpInputFile, argv[2] ) ;
LPTSTR lpOutputFile = new char[ strlen(argv[3]) ] ;
strcpy ( lpOutputFile, argv[3] ) ;
SECURITY_ATTRIBUTES saAttr;
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL;
/************************************************
* redirecting child process's STDOUT *
************************************************/
hSaveStdout = GetStdHandle(STD_OUTPUT_HANDLE);
if (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0))
ErrorExit("Stdout pipe creation failed/n");
if (! SetStdHandle(STD_OUTPUT_HANDLE, hChildStdoutWr))
ErrorExit("Redirecting STDOUT failed");
BOOL fSuccess = DuplicateHandle(
GetCurrentProcess(),
hChildStdoutRd,
GetCurrentProcess(),
&hChildStdoutRdDup ,
0,
FALSE,
DUPLICATE_SAME_ACCESS);
if( !fSuccess )
ErrorExit("DuplicateHandle failed");
CloseHandle(hChildStdoutRd);
/************************************************
* redirecting child process's STDIN *
************************************************/
hSaveStdin = GetStdHandle(STD_INPUT_HANDLE);
if (! CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0))
ErrorExit("Stdin pipe creation failed/n");
if (! SetStdHandle(STD_INPUT_HANDLE, hChildStdinRd))
ErrorExit("Redirecting Stdin failed");
fSuccess = DuplicateHandle(
GetCurrentProcess(),
hChildStdinWr,
GetCurrentProcess(),
&hChildStdinWrDup,
0,
FALSE,
DUPLICATE_SAME_ACCESS);
if (! fSuccess)
ErrorExit("DuplicateHandle failed");
CloseHandle(hChildStdinWr);
/************************************************
* 建立子進程（即啓動SAMPLE.EXE） *
************************************************/
fSuccess = CreateChildProcess( lpProgram );
if ( !fSuccess )
ErrorExit("Create process failed");
// 父進程輸入輸出流的還原設置
if (! SetStdHandle(STD_INPUT_HANDLE, hSaveStdin))
ErrorExit("Re-redirecting Stdin failed/n");
if (! SetStdHandle(STD_OUTPUT_HANDLE, hSaveStdout))
ErrorExit("Re-redirecting Stdout failed/n");
WriteToPipe( lpInputFile ) ;
ReadFromPipe( lpOutputFile );
delete lpProgram ;
delete lpInputFile ;
delete lpOutputFile ;
}
BOOL CreateChildProcess( LPTSTR lpProgram )
{
PROCESS_INFORMATION piProcInfo;
STARTUPINFO siStartInfo;
BOOL bFuncRetn = FALSE;
ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
siStartInfo.cb = sizeof(STARTUPINFO);
bFuncRetn = CreateProcess ( NULL, lpProgram, NULL, NULL, TRUE, /
0, NULL, NULL, &siStartInfo, &piProcInfo);
if (bFuncRetn == 0)
{
ErrorExit("CreateProcess failed/n");
return 0;
}
else
{
CloseHandle(piProcInfo.hProcess);
CloseHandle(piProcInfo.hThread);
return bFuncRetn;
}
}
VOID WriteToPipe( LPTSTR lpInputFile )
{
HANDLE hInputFile = CreateFile(lpInputFile, GENERIC_READ, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
if (hInputFile == INVALID_HANDLE_VALUE)
return ;
BOOL fSuccess ;
DWORD dwRead, dwWritten;
CHAR chBuf[BUFSIZE] = {0} ;
for (;;)
{
fSuccess = ReadFile( hInputFile, chBuf, BUFSIZE, &dwRead, NULL) ;
if ( !fSuccess || dwRead == 0)
break;
fSuccess = WriteFile( hChildStdinWrDup, chBuf, dwRead, &dwWritten, NULL) ;
if ( !fSuccess )
break;
}
if (! CloseHandle(hChildStdinWrDup))
ErrorExit("Close pipe failed/n");
CloseHandle ( hInputFile ) ;
}
VOID ReadFromPipe( LPTSTR lpOutputFile )
{
HANDLE hOutputFile = CreateFile( lpOutputFile, GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hOutputFile == INVALID_HANDLE_VALUE)
return ;
BOOL fSuccess ;
DWORD dwRead, dwWritten;
CHAR chBuf[BUFSIZE] = { 0 };
if (!CloseHandle(hChildStdoutWr))
ErrorExit("Closing handle failed");
for (;;)
{
fSuccess = ReadFile( hChildStdoutRdDup, chBuf, BUFSIZE, &dwRead, NULL) ;
if( !fSuccess || dwRead == 0)
{
break;
}
fSuccess = WriteFile( hOutputFile, chBuf, dwRead, &dwWritten, NULL) ;
if ( !fSuccess )
break;
}
CloseHandle ( hOutputFile ) ;
}
VOID ErrorExit (LPTSTR lpszMessage)
{
MessageBox( 0, lpszMessage, 0, 0 );
}

2、命名管道
命名管道具備如下幾個特徵：
（1）命名管道是雙向的，因此兩個進程能夠經過同一管道進行交互。
（2）命名管道不但能夠面向字節流，還能夠面向消息，因此讀取進程能夠讀取寫進程發送的不一樣長度的消息。
（3）多個獨立的管道實例能夠用一個名稱來命名。例如幾個客戶端可使用名稱相同的管道與同一個服務器進行併發通訊。
（4）命名管道能夠用於網絡間兩個進程的通訊，而其實現的過程與本地進程通訊徹底一致。
實驗目標：在客戶端輸入數據a和b，而後發送到服務器並計算a+b,而後把計算結果發送到客戶端。能夠多個客戶端與同一個服務器並行通訊。
界面設計：

難點所在：
實現的過程比較簡單，但有一個難點。本來當服務端使用ConnectNamedPipe函數後，若是有客戶端鏈接，就能夠直接進行交互。原來我在實現過程當中，當管道空閒時，管道的線程函數會無限（INFINITE）阻塞。若如今須要中止服務，就必須結束全部的線程，TernimateThread能夠做爲一個結束線程的方法，但我基本不用這個函數。一旦使用這個函數以後，目標線程就會當即結束，但若是此時的目標線程正在操做互斥資源、內核調用、或者是操做共享DLL的全局變量，可能會出現互斥資源沒法釋放、內核異常等現象。這裏我用重疊I/0來解決這個問題，在建立PIPE時使用FILE_FLAG_OVERLAPPED標誌，這樣使用ConnectNamedPipe後會當即返回，但線程的阻塞由等待函數WaitForSingleObject來實現，等待OVERLAPPED結構的事件對象被設置。
客戶端主要代碼：

代碼:

[cpp] view plain copy

void CMyDlg::OnSubmit()
{
// 打開管道
HANDLE hPipe = CreateFile("////.//Pipe//NamedPipe", GENERIC_READ | GENERIC_WRITE, /
0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL) ;
if ( hPipe == INVALID_HANDLE_VALUE )
{
this->MessageBox ( "打開管道失敗，服務器還沒有啓動,或者客戶端數量過多" ) ;
return ;
}
DWORD nReadByte, nWriteByte ;
char szBuf[1024] = {0} ;
// 把兩個整數(a,b)格式化爲字符串
sprintf ( szBuf, "%d %d", this->nFirst, this->nSecond ) ;
// 把數據寫入管道
WriteFile ( hPipe, szBuf, strlen(szBuf), &nWriteByte, NULL ) ;
memset ( szBuf, 0, sizeof(szBuf) ) ;
// 讀取服務器的反饋信息
ReadFile ( hPipe, szBuf, 1024, &nReadByte, NULL ) ;
// 把返回信息格式化爲整數
sscanf ( szBuf, "%d", &(this->nResValue) ) ;
this->UpdateData ( false ) ;
CloseHandle ( hPipe ) ;
}

服務端主要代碼：

代碼:

[cpp] view plain copy

// 啓動服務
void CMyDlg::OnStart()
{
CString lpPipeName = "////.//Pipe//NamedPipe" ;
for ( UINT i = 0; i < nMaxConn; i++ )
{
// 建立管道實例
PipeInst[i].hPipe = CreateNamedPipe ( lpPipeName, PIPE_ACCESS_DUPLEX|FILE_FLAG_OVERLAPPED, /
PIPE_TYPE_BYTE|PIPE_READMODE_BYTE|PIPE_WAIT, nMaxConn, 0, 0, 1000, NULL ) ;
if ( PipeInst[i].hPipe == INVALID_HANDLE_VALUE )
{
DWORD dwErrorCode = GetLastError () ;
this->MessageBox ( "建立管道錯誤！" ) ;
return ;
}
// 爲每一個管道實例建立一個事件對象，用於實現重疊IO
PipeInst[i].hEvent = CreateEvent ( NULL, false, false, false ) ;
// 爲每一個管道實例分配一個線程，用於響應客戶端的請求
PipeInst[i].hTread = AfxBeginThread ( ServerThread, &PipeInst[i], THREAD_PRIORITY_NORMAL ) ;
}
this->SetWindowText ( "命名管道實例之服務器(運行)" ) ;
this->MessageBox ( "服務啓動成功" ) ;
}
// 中止服務
void CMyDlg::OnStop()
{
DWORD dwNewMode = PIPE_TYPE_BYTE|PIPE_READMODE_BYTE|PIPE_NOWAIT ;
for ( UINT i = 0; i < nMaxConn; i++ )
{
SetEvent ( PipeInst[i].hEvent ) ;
CloseHandle ( PipeInst[i].hTread ) ;
CloseHandle ( PipeInst[i].hPipe ) ;
}
this->SetWindowText ( "命名管道實例之服務器" ) ;
this->MessageBox ( "中止啓動成功" ) ;
}
// 線程服務函數
UINT ServerThread ( LPVOID lpParameter )
{
DWORD nReadByte = 0, nWriteByte = 0, dwByte = 0 ;
char szBuf[MAX_BUFFER_SIZE] = {0} ;
PIPE_INSTRUCT CurPipeInst = *(PIPE_INSTRUCT*)lpParameter ;
OVERLAPPED OverLapStruct = { 0, 0, 0, 0, CurPipeInst.hEvent } ;
while ( true )
{
memset ( szBuf, 0, sizeof(szBuf) ) ;
// 命名管道的鏈接函數，等待客戶端的鏈接（只針對NT）
ConnectNamedPipe ( CurPipeInst.hPipe, &OverLapStruct ) ;
// 實現重疊I/0，等待OVERLAPPED結構的事件對象
WaitForSingleObject ( CurPipeInst.hEvent, INFINITE ) ;
// 檢測I/0是否已經完成，若是未完成，意味着該事件對象是人工設置，即服務須要中止
if ( !GetOverlappedResult ( CurPipeInst.hPipe, &OverLapStruct, &dwByte, true ) )
break ;
// 從管道中讀取客戶端的請求信息
if ( !ReadFile ( CurPipeInst.hPipe, szBuf, MAX_BUFFER_SIZE, &nReadByte, NULL ) )
{
MessageBox ( 0, "讀取管道錯誤！", 0, 0 ) ;
break ;
}
int a, b ;
sscanf ( szBuf, "%d %d", &a, &b ) ;
pMyDlg->nFirst = a ;
pMyDlg->nSecond = b ;
pMyDlg->nResValue = a + b ;
memset ( szBuf, 0, sizeof(szBuf) ) ;
sprintf ( szBuf, "%d", pMyDlg->nResValue ) ;
// 把反饋信息寫入管道
WriteFile ( CurPipeInst.hPipe, szBuf, strlen(szBuf), &nWriteByte, NULL ) ;
pMyDlg->SetDlgItemInt ( IDC_FIRST, a, true ) ;
pMyDlg->SetDlgItemInt ( IDC_SECOND, b, true ) ;
pMyDlg->SetDlgItemInt ( IDC_RESULT, pMyDlg->nResValue, true ) ;
// 斷開客戶端的鏈接，以便等待下一客戶的到來
DisconnectNamedPipe ( CurPipeInst.hPipe ) ;
}
return 0 ;
}