Windows 多进程通讯API总结

时间 2019-12-20

原文原文链接

在一个大型的应用系统中，每每须要多个进程相互协做，进程间通讯(IPC,Inter Process Communication)就显得比较重要了。在Linux系统中，有不少种IPC机制，好比说，信号(signal)、管道(pipe)、消息队列(message queue)、信号量(semaphore)和共享内存(shared memory)、套接字(socket)等，其实Windows操做系统也支持这些东西。在IBM的Developerworks发现了一篇关于Windows与Linux 之间IPC机制API比较的文章，写得很不错，连接html

http://www.ibm.com/developerworks/cn/linux/l-ipc2lin1.htmllinux

下面大部份内容是关于这些机制的API的实现。ios

建立进程

进程的建立能够调用CreateProcess函数，CreateProcess有三个重要的参数，运行进程的名称、指向STARTUPINFO结构的指针、指向PROCESS_INFORMATION结构的指针。其原型以下：windows

[cpp] view plain copy print ?浏览器

BOOL CreateProcess 安全
( 服务器
LPCTSTRlpApplicationName, app
LPTSTR lpCommandLine, socket
LPSECURITY_ATTRIBUTES lpProcessAttributes。函数
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCTSTR lpCurrentDirectory,
LPSTARTUPINFOlpStartupInfo,
LPPROCESS_INFORMATIONlpProcessInformation
);

给个例子，若是启动时应用程序带有命令行参数，进程将输出命令行参数，并建立一个不带任何参数的子线程；若是不带有任何参数，则会输出一条提示消息。

[cpp] view plain copy print ?

#include <Windows.h>
#include <tchar.h>
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[]){
STARTUPINFO startup_info;
PROCESS_INFORMATION process_info;
if (argc>1)
{
cout<<"Argument"<<argv[1]<<endl;
cout<<"开启子线程"<<endl;
ZeroMemory(&process_info,sizeof(process_info));
ZeroMemory(&startup_info,sizeof(startup_info));
startup_info.cb=sizeof(startup_info);
if (CreateProcess(argv[0],0,0,0,0,0,0,0,&startup_info,&process_info)==0)
{
cout<<"Error"<<endl;
}
WaitForSingleObject(process_info.hProcess,INFINITE);
}
else{
cout<<"No arguments"<<endl;
}
getchar();
}

再给个例子，利用CreateProcess开启一个新线程，启动IE浏览器，打开百度的主页，5s后再将其关闭。

[cpp] view plain copy print ?

#include <Windows.h>
#include <tchar.h>
#include <iostream>
using namespace std;
#define IE L"C:\\Program Files\\Internet Explorer\\iexplore.exe"
#define CMD L"open http://www.baidu.com/"
int _tmain(int argc, _TCHAR* argv[]){
STARTUPINFO startup_info;
GetStartupInfo(&startup_info);
PROCESS_INFORMATION process_info;
startup_info.dwFlags=STARTF_USESHOWWINDOW;
startup_info.wShowWindow=SW_HIDE;
if (!CreateProcess(IE,CMD,NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL,&startup_info,&process_info))
{
cout<<"Create Process Error："<<GetLastError()<<endl;
return 0;
}
Sleep(5000);
TerminateProcess(process_info.hProcess,0);
return 0;
}

被建立的句柄经过process_info.hProcess返回。若是传递参数给新的进程，第一个命令行参数必须重复应用程序名称，整个命令行会被传递给子进程。

传递参数给新进程。

[cpp] view plain copy print ?

#include <Windows.h>
#include <tchar.h>
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[]){
STARTUPINFO startup_info;
PROCESS_INFORMATION process_info;
if (argc==1)
{
cout<<"No arguments given starting child process"<<endl;
wchar_t argument[256];
wsprintf(argument,L"\"%s\" Hello",argv[0]);
ZeroMemory(&process_info,sizeof(process_info));
ZeroMemory(&startup_info,sizeof(startup_info));
startup_info.cb=sizeof(startup_info);
if (CreateProcess(argv[0],argument,0,0,0,0,0,0,&startup_info,&process_info)==0)
{
cout<<"Error "<<GetLastError()<<endl;
}
WaitForSingleObject(process_info.hProcess,INFINITE);
}
else{
cout<<"Argument "<<argv[1]<<endl;
}
getchar();
}

IPC

进程间能够共享内存，进程创建具备共享属性的内存区域后，另外一个进程能够打开此内存区域，并将其映射到本身的地址空间。共享内存可使用文件映射函数CreateFileMapping，建立共享内存区域的句柄，经过MapViewOfFile()把这个区域映射到进程，而后再链接到现有的共享内存区域，能够经过OpenFileMapping得到句柄。在进程使用完共享内存后，须要调用UnmapViewOfFile()取消映射，再调用CloseHandle()关闭相应的句柄，避免内存泄露。

给个例子，若是启动时应用程序不带任何参数，应用程序会建立一个子进程。父进程也将创建一个共享内存区域，并将一个字符串保存到共享内存。共享内存取名为sharedmemory，在Local\命名空间中建立，即该共享内存对该用户全部的所有进程可见。(进程的命名空间分为两种，全局命名空间以Global\标识符开头，本地命名空间以Local\开头)

[cpp] view plain copy print ?

#include <Windows.h>
#include <tchar.h>
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[]){
STARTUPINFO startup_info;
PROCESS_INFORMATION process_info;
HANDLE filehandle;
TCHAR ID[]=TEXT("Local\\sharedmemory");
char* memory;
if (argc==1)
{
filehandle=CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,1024,ID);
memory=(char*)MapViewOfFile(filehandle,FILE_MAP_ALL_ACCESS,0,0,0);
sprintf_s(memory,1024,"%s","Data from first process");
cout<<"First process:"<<memory<<endl;
ZeroMemory(&process_info,sizeof(process_info));
ZeroMemory(&startup_info,sizeof(startup_info));
startup_info.cb=sizeof(startup_info);
wchar_t cmdline[256];
wsprintf(cmdline,L"\"%s\" Child\n",argv[0]);
CreateProcessW(argv[0],cmdline,0,0,0,0,0,0,&startup_info,&process_info);
WaitForSingleObject(process_info.hProcess,INFINITE);
UnmapViewOfFile(memory);
CloseHandle(filehandle);
}
else{
filehandle=OpenFileMapping(FILE_MAP_ALL_ACCESS,0,ID);
memory=(char*)MapViewOfFile(filehandle,FILE_MAP_ALL_ACCESS,0,0,0);
cout<<"Second process: "<<memory;
UnmapViewOfFile(memory);
CloseHandle(filehandle);
}
getchar();
return 0;
}

从结果能够看出，子进程链接到共享内存，并能输出父进程存储在那里的字符串。子进程输出字符串之后，就取消内存映射，关闭文件句柄，而后退出。子进程退出后，父进程就能够取消内存映射、关闭文件句柄并退出。

子进程能够继承父进程全部资源的句柄，最简单的方法是经过命令行传递值。

[cpp] view plain copy print ?

#include <Windows.h>
#include <tchar.h>
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[]){
STARTUPINFO startup_info;
PROCESS_INFORMATION process_info;
SECURITY_ATTRIBUTES sa;
HANDLE filehandle;
TCHAR ID[]=TEXT("Local\\sharedmemory");
wchar_t* memory;
if (argc==1)
{
//父进程
sa.nLength=sizeof(sa);//设置安全属性
sa.bInheritHandle=TRUE;//使句柄能够被继承
sa.lpSecurityDescriptor=NULL;
filehandle=CreateFileMapping(INVALID_HANDLE_VALUE,&sa,PAGE_READWRITE,0,1024,ID);
memory=(wchar_t*)MapViewOfFile(filehandle,FILE_MAP_ALL_ACCESS,0,0,0);
//用共享内存设置命令行
swprintf(memory,1024,L"\"%s\" %i",argv[0],filehandle);
cout<<"First process memory:"<<memory<<" handle: "<<filehandle<<endl;
ZeroMemory(&process_info,sizeof(process_info));
ZeroMemory(&startup_info,sizeof(startup_info));
startup_info.cb=sizeof(startup_info);
//启动子进程
CreateProcess(NULL,memory,0,0,true,0,0,0,&startup_info,&process_info);
WaitForSingleObject(process_info.hProcess,INFINITE);
UnmapViewOfFile(memory);
CloseHandle(filehandle);
}
else{
filehandle=(HANDLE)_wtoi(argv[1]);//从argv[1]得到句柄
memory=(wchar_t*)MapViewOfFile(filehandle,FILE_MAP_ALL_ACCESS,0,0,0);
cout<<"Second process memory : "<<memory<<" handle: "<<filehandle<<endl;
UnmapViewOfFile(memory);
CloseHandle(filehandle);
}
getchar();
return 0;
}

进程间共享互斥量，能够经过调用CreateMutex或者OpenMutex函数来获取互斥量的句柄。可是，只有一个进程能够建立互斥量，其余的进程只能打开现有的互斥量；互斥量的名称必须惟一；互斥量的名称必须传递给其余进程。

[cpp] view plain copy print ?

#include <Windows.h>
#include <tchar.h>
#include <iostream>
using namespace std;
int _tmain(int argc, _TCHAR* argv[]){
HANDLE sharedmutex;
STARTUPINFO startup_info;
PROCESS_INFORMATION process_info;
ZeroMemory(&process_info,sizeof(process_info));
ZeroMemory(&startup_info,sizeof(startup_info));
startup_info.cb=sizeof(startup_info);
sharedmutex=CreateMutex(0,0,L"mymutex");
if (GetLastError()!=ERROR_ALIAS_EXISTS)
{
if (CreateProcess(argv[0],0,0,0,0,0,0,0,&startup_info,&process_info)==0)
{
cout<<"Error : "<<GetLastError()<<endl;
}
WaitForSingleObject(process_info.hProcess,INFINITE);
}
WaitForSingleObject(sharedmutex,INFINITE);
for (int i=0;i<100;i++)
{
cout<<"Process "<<GetCurrentProcessId()<<" count"<<i<<endl;
}
ReleaseMutex(sharedmutex);
CloseHandle(sharedmutex);
getchar();
return 0;
}

使用共享互斥量来确保两个进程中一次只有一个能计数从0数到19，若是没有互斥量的话，那么两个进程可能同时在跑，则控制台的输出将是混合的输出，使用互斥量之后，一次只有一个进程在输出。

也能够用管道进行通讯，管道是流式通讯的一种方式，管道有两种命名管道和匿名管道。匿名管道的建立能够调用CreatePipe()，建立命名管道能够调用CreateNamedPipe()，调用WriteFile经过管道发送数据，ReadFile从管道读取数据。

[cpp] view plain copy print ?

#include <Windows.h>
#include <tchar.h>
#include <process.h>
#include <iostream>
#include <stdio.h>
using namespace std;
HANDLE readpipe,writepipe;
unsigned int __stdcall stage1(void * param)
{
char buf[200];
DWORD len;
for (int i=0;i<10;i++)
{
sprintf(buf,"Text %i",i);
WriteFile(writepipe,buf,strlen(buf)+1,&len,0);
}
CloseHandle(writepipe);
return 0;
}
unsigned int __stdcall stage2(void * param)
{
char buf[200];
DWORD len;
while(ReadFile(readpipe,buf,200,&len,0))
{
DWORD offset=0;
while(offset<len)
{
cout<<&buf[offset]<<endl;
offset+=strlen(&buf[offset])+1;
}
}
CloseHandle(readpipe);
return 0;
}
int _tmain(int argc, _TCHAR* argv[]){
HANDLE thread1,thread2;
CreatePipe(&readpipe,&writepipe,0,0);
thread1=(HANDLE)_beginthreadex(0,0,&stage1,0,0,0);
thread2=(HANDLE)_beginthreadex(0,0,&stage2,0,0,0);
WaitForSingleObject(thread1,INFINITE);
WaitForSingleObject(thread2,INFINITE);
getchar();
return 0;
}

第一个线程将文本信息放入管道，第二个线程接收并输出这些信息。

还能够用套接字进行通讯。WindowsSockets API以BSD Sockets API为基础，与类UNIX操做系统的代码很类似。

[cpp] view plain copy print ?

#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <Windows.h>
#include <tchar.h>
#include <process.h>
#include <WinSock2.h>
#include <iostream>
#include <stdio.h>
#pragma comment(lib,"ws2_32.lib")
using namespace std;
HANDLE hevent;
//响应线程
void handleecho(void *data)
{
char buf[1024];
int count;
ZeroMemory(buf,sizeof(buf));
int socket=(int)data;
while((count=recv(socket,buf,1023,0))>0)
{
cout<<"received "<<buf<<"from client"<<endl;
int ret=send(socket,buf,count,0);
}
cout<<"close echo thread"<<endl;
shutdown(socket,SD_BOTH);
closesocket(socket);
}
//客户端线程
unsigned int __stdcall client(void *data)
{
SOCKET ConnectSockket=socket(AF_INET,SOCK_STREAM,0);
WaitForSingleObject(hevent,INFINITE);
struct sockaddr_in server;
ZeroMemory(&server,sizeof(server));
server.sin_family=AF_INET;
server.sin_addr.s_addr=inet_addr("192.168.1.107");
server.sin_port=7780;
connect(ConnectSockket,(struct sockaddr*)&server,sizeof(server));
cout<<"send 'abcd' to server"<<endl;
char buf[1024];
ZeroMemory(buf,sizeof(buf));
strncpy_s(buf,1024,"abcd",5);
send(ConnectSockket,buf,strlen(buf)+1,0);
ZeroMemory(buf,sizeof(buf));
recv(ConnectSockket,buf,1024,0);
//cout<<"get "<<buf<<"from server"<<endl;
printf("get '%s' from server\n",buf);
cout<<"close client"<<endl;
shutdown(ConnectSockket,SD_BOTH);
closesocket(ConnectSockket);
return 0;
}
//服务器线程
unsigned int __stdcall server(void *data)
{
SOCKET newsocket;
SOCKET ServerSocket=socket(AF_INET,SOCK_STREAM,0);
struct sockaddr_in server;
ZeroMemory(&server,sizeof(server));
server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=7780;
bind(ServerSocket,(struct sockaddr*)&server,sizeof(server));
listen(ServerSocket,SOMAXCONN);
SetEvent(hevent);
while((newsocket=accept(ServerSocket,0,0))!=INVALID_SOCKET)
{
HANDLE newthread;
newthread=(HANDLE)_beginthread(&handleecho,0,(void *)newsocket);
}
cout<<"close server"<<endl;
shutdown(ServerSocket,SD_BOTH);
closesocket(ServerSocket);
return 0;
}
//主线程启动客户端线程和服务端线程
int _tmain(int argc, _TCHAR* argv[]){
HANDLE serverthread,clienthread;
WSADATA wsaData;
WSAStartup(MAKEWORD(2,2),&wsaData);
hevent=CreateEvent(0,true,0,0);
serverthread=(HANDLE)_beginthreadex(0,0,&server,0,0,0);
clienthread=(HANDLE)_beginthreadex(0,0,&client,0,0,0);
WaitForSingleObject(clienthread,INFINITE);
CloseHandle(clienthread);
CloseHandle(hevent);
getchar();
WSACleanup();
return 0;
}

服务器线程的第一个操做是打开一个套接字，接着绑定链接。套接字置于监听状态，值SOMAXCONN包含排队等待接受的链接的最大值。而后服务器发信号给事件，事件继而使客户端线程尝试链接。接着，主线程循环等待接受链接，直到收到INVALID_SOCKET的链接。Windows套接字关闭时会发生这种状况。服务器线程在其余线程退出后清理退出。服务器每次接受一个链接时都会建立一个新线程，且新链接的标识会传递给新建立的线程。当循环收到INVALID_SOCKET时，服务器线程关闭，而后关闭套接字。

Windows API也提供了不少原子操做，互锁函数。InterlockedIncrement就是一个互锁函数。

[cpp] view plain copy print ?

#include <Windows.h>
#include <tchar.h>
#include <process.h>
#include <iostream>
using namespace std;
int isPrime(int num)
{
int i;
for (i=2;i<(int)(sqrt((float)num)+1.0);i++)
{
if (num%i==0)
return 0;
}
return 1;
}
volatile long counter=2;
unsigned int __stdcall test(void *)
{
while (counter<20)
{
int num=InterlockedIncrement(&counter);
//int num=counter++;
printf("Thread ID : %i; value = %i, is prime = %i\n",GetCurrentThreadId(),num,isPrime(num));
}
return 0;
}
int _tmain(int argc,_TCHAR* argv[])
{
HANDLE h1,h2;
h1=(HANDLE)_beginthreadex(0,0,&test,(void *)0,0,0);
h2=(HANDLE)_beginthreadex(0,0,&test,(void *)0,0,0);
WaitForSingleObject(h1,INFINITE);
WaitForSingleObject(h2,INFINITE);
CloseHandle(h1);
CloseHandle(h2);
getchar();
return 0;
}

还有一个问题就是线程本地存储(TLS, ThreadLocal Storage)，TLS 是一个机制，利用该机制，程序能够拥有全局变量，但处于“每一线程各不相同”的状态。也就是说，进程中的全部线程均可以拥有全局变量，但这些变量实际上是特定对某个线程才有意义，各个线程拥有全局变量的一个副本，各自之间不相影响。每一个线程访问数据的方式相同，但看不到其余线程持有的值。好比说，定义一个全局变量int a=10，那么在线程1中对a进行操做a=a-1，若是没用TLS，那么线程2开始得到的a就是9。可是，若是采起了TLS，无论线程1中对a的值进行了如何的修改操做，其余的线程一开始得到的a仍是10，不会被修改。这个全局的变量a是没有存储在线程堆栈中的，是在全局的堆栈中，可是却被各个线程“共享”且互不影响。能够认为线程本地存储的本质是“全局”数据的做用域受到了执行线程的限制。

线程本地分配能够调用__declspec、TlsAlloc()等函数。TlsAlloc能够分配全局索引，该索引由全部线程共享，可是每一个线程存储在索引中的数据为调用的线程私有，也就是说其余线程看不到持有的值。当再也不须要全局索引提供线程本地存储时，能够调用TlsFree来释放全局索引。

给个例子。

[cpp] view plain copy print ?

#include <Windows.h>
#include <tchar.h>
#include <process.h>
#include <iostream>
using namespace std;
DWORD TLSIndex;
void setdata(int value)
{
cout<<"Thread "<<GetCurrentThreadId()<<": set value = "<<value<<endl;
TlsSetValue(TLSIndex,(void*)value);
}
void getdata()
{
int value;
value=(int)TlsGetValue(TLSIndex);
cout<<"Thread "<<GetCurrentThreadId()<<": has value = "<<value<<endl;
}
unsigned int __stdcall workthread(void *data)
{
int value=(int)data;
cout<<"Thread "<<GetCurrentThreadId()<<": got value = "<<value<<endl;
setdata(value);
Sleep(1000);
getdata();
return 0;
}
int _tmain(int argc,_TCHAR* argv[])
{
HANDLE h[8];
TLSIndex=TlsAlloc();
for (int i=0;i<8;i++)
{
h[i]=(HANDLE)_beginthreadex(0,0,&workthread,(void*)i,0,0);
}
for (int i=0;i<8;i++)
{
WaitForSingleObject(h[i],INFINITE);
}
TlsFree(TLSIndex);
getchar();
return 0;
}

线程本地存储用于保存传给各个线程的值，每一个线程在被建立的时候就被传递一个惟一的值，并经过setdata存储在线程本地存储中。getdata能够读取线程本地值，每一个线程调用setdata方法，接着休眠1s让其余线程运行，而后调用getdata读取数据。

还有个问题，就是优先级的问题。线程的优先级越高，得到的CPU资源(时间)就越多。在有些状况下，调整一个应用程序中不一样线程的优先级会很是有用。好比说，当某个应用执行一个长时间的后台任务时，为了保证机器的高响应性，这个后台任务最好以低优先级运行。

Windows操做系统中提供了相关的API。

[cpp] view plain copy print ?

#include <Windows.h>
#include <tchar.h>
#include <process.h>
#include <iostream>
#include <time.h>
using namespace std;
unsigned int __stdcall fastthread(void *data)
{
double d=1.0;
cout<<"fast thread started"<<endl;
SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_ABOVE_NORMAL);
clock_t start=clock();
for (int i=0;i<1000000000;i++)
{
d+=i;
}
clock_t end=clock();
cout<<"fast thread finished, it takes "<<(double)(end-start)/CLOCKS_PER_SEC<<"s to finish the task"<<endl;
return 0;
}
unsigned int __stdcall slowthread(void *data)
{
double d=0.0;
cout<<"slow thread started"<<endl;
SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_BELOW_NORMAL);
clock_t start=clock();
for (int i=0;i<1000000000;i++)
{
d+=i;
}
clock_t end=clock();
cout<<"slow thread finished, it takes "<<(double)(end-start)/CLOCKS_PER_SEC<<"s to finnish the task"<<endl;
return 0;
}
int _tmain(int argc,_TCHAR* argv[])
{
HANDLE fast,slow;
slow=(HANDLE)_beginthreadex(0,0,&slowthread,0,0,0);
fast=(HANDLE)_beginthreadex(0,0,&fastthread,0,0,0);
WaitForSingleObject(fast,INFINITE);
WaitForSingleObject(slow,INFINITE);
getchar();
return 0;
}

有时候调整线程的优先级会带来优先级反转的问题。

小结

主要实现了windows操做系统中IPC的API，主要有进程之间共享内存、子进程中继承句柄、互斥量、管道、套接字等。此外，还有Windows中的互锁函数。线程本地化存储(TLS)、线程的优先级等。