Windows多进程通信API总结

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

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

#include 
#include 
#include 
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:"<		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: "<		UnmapViewOfFile(memory);
		CloseHandle(filehandle);
	}
	getchar();
	return 0;
}

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

子进程可以继承父进程所有资源的句柄，最简单的方法是通过命令行传递值。

#include 
#include 
#include 
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:"<		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 : "<		UnmapViewOfFile(memory);
		CloseHandle(filehandle);
	}
	getchar();
	return 0;
}

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

#include 
#include 
#include 
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 : "<		}
		WaitForSingleObject(process_info.hProcess,INFINITE);
	}

	WaitForSingleObject(sharedmutex,INFINITE);
	for (int i=0;i<100;i++)
	{
		cout<<"Process "<	}
	ReleaseMutex(sharedmutex);
	CloseHandle(sharedmutex);
	getchar();
	return 0;
}

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

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

#include 
#include 
#include 
#include 
#include 
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		{
			cout<<&buf[offset]<			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操作系统的代码很相似。

#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include 
#include 
#include 
#include 
#include 
#include 
#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 "<		int ret=send(socket,buf,count,0);
	}
	cout<<"close echo thread"<	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 &＃39;abcd&＃39; to server"<	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 "<	printf("get &＃39;%s&＃39; from server\n",buf);

	cout<<"close client"<	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"<	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就是一个互锁函数。

#include 
#include 
#include 
#include 
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来释放全局索引。

给个例子。

#include 
#include 
#include 
#include 
using namespace std;
DWORD TLSIndex;
void setdata(int value)
{
	cout<<"Thread "<#include 
#include 
#include 
#include 
#include 
using namespace std;
unsigned int __stdcall fastthread(void *data)
{
	double d=1.0;
	cout<<"fast thread started"<	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"<	return 0;
}
unsigned int __stdcall slowthread(void *data)
{
	double d=0.0;
	cout<<"slow thread started"<	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"<	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;
}

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