C++进程间通信（windows）

C++ 进程间通信方式

1，共享内存；
2，管道；
3，信号量
进程1测试代码如下：

#include <Windows.h>
#include <iostream>
/*********************1 共享内存**********************/
HANDLE myHMutex;
HANDLE myHEvent;
BOOL SharedMemoryFun();
/*********************2 命名管道**********************/
#define MY_PIPE_NAME "\\\\.\\pipe\\mypipe"
BOOL PipeFun();
/*********************3 信号量************************/
HANDLE myHSemaphore;
BOOL SemaphoreFun();

int main()
{
	/*if (SharedMemoryFun() == FALSE)
	{
	std::cout<<"SharedMemoryFun ERROR"<<std::endl;
	}*/
	
	/*if (PipeFun() == FALSE)
	{
	std::cout<<"PipeFun ERROR"<<std::endl;
	}*/

	if (SemaphoreFun() == FALSE)
	{
		std::cout<<"SemaphoreFun ERROR"<<std::endl;
	}

	system("pause");
	return 0;
}

BOOL SharedMemoryFun()
{
	//创建共享文件句柄
	HANDLE myhandle = CreateFileMapping(INVALID_HANDLE_VALUE,
		NULL,//安全级别
		PAGE_READWRITE,
		0,//高位文件大小
		1024,//低位文件大小
		"MYSM");//共享文件名称
	if (myhandle == NULL)
	{
		return FALSE;
	}

	//映射
	LPVOID lpbuf = MapViewOfFile(myhandle, 
		FILE_MAP_ALL_ACCESS,
		0,
		0,
		1024);
	if (lpbuf == NULL)
	{
		return FALSE;
		CloseHandle(myhandle);
	}

	myHMutex = CreateMutex(NULL, FALSE, "MYMUTEX");
	myHEvent = CreateEvent(NULL, FALSE, FALSE, "MYEVENT");

	while(TRUE)
	{
		char buf[128];
		std::cout<<"*************Send Message**********************"<<std::endl;
		std::cin.getline(buf, 128);

		WaitForSingleObject(myHMutex, INFINITE);
		memcpy(lpbuf, buf, strlen(buf));
		ReleaseMutex(myHMutex);
		SetEvent(myHEvent);
		if (buf[0] == 'q')
		{
			break;
		}
	}

	CloseHandle(myHEvent);
	CloseHandle(myHMutex);

	UnmapViewOfFile(lpbuf);
	CloseHandle(myhandle);
	return TRUE;
}

BOOL PipeFun()
{
	HANDLE myHPipe = CreateNamedPipe(
		MY_PIPE_NAME,
		PIPE_ACCESS_DUPLEX, //管道访问方式：PIPE_ACCESS_DUPLEX指双向模式
		PIPE_TYPE_MESSAGE | //命名管道句柄的写入方式：以数据块的方式写入管道
		PIPE_READMODE_MESSAGE | //命名管道句柄的读取方式：以数据块的方式从管道读取
		PIPE_WAIT, //命名管道句柄的等待方式：阻塞方式
		PIPE_UNLIMITED_INSTANCES, //管道所能创建的最大实例个数：1~255，
		0, //管道的输出缓冲区容量，0表示默认大小
		0, //管道的输入缓冲区容量，0表示默认大小 
		1000, //管道的默认等待超时，单位毫秒
		NULL); //管道的安全性，NULL表示windows提供的默认安全
	if (myHPipe == INVALID_HANDLE_VALUE)
	{
		return FALSE;
	}

	if (!ConnectNamedPipe(myHPipe, NULL))
	{
		return FALSE;
	}

	while (TRUE)
	{
		char wbuf[128];
		std::cout<<"*************Send Message**********************"<<std::endl;
		std::cin.getline(wbuf, 128);
		DWORD wr;
		if (!WriteFile(myHPipe, wbuf, 128, &wr, NULL))
		{
			std::cout<<"WriteFile"<<std::endl;
		}

		char rbuf[128];
		DWORD rs;
		if (!ReadFile(myHPipe, rbuf, 128, &rs, NULL))
		{
			std::cout<<"ReadFile"<<std::endl;
		}
		else
		{
			std::cout<<rbuf<<std::endl;
		}	

	}

	DisconnectNamedPipe(myHPipe);
	CloseHandle(myHPipe);
	return TRUE;
}

BOOL SemaphoreFun()
{
	myHSemaphore = CreateSemaphore(NULL, FALSE, TRUE, "MYSEM");
	if (myHSemaphore == NULL)
	{
		return FALSE;
	}

	std::cout<<"wait ReleaseSemaphore"<<std::endl;
	Sleep(10500);
	ReleaseSemaphore(myHSemaphore, 1, NULL);
	while(1)
	{
		std::cout<<"runing "<<std::endl;
		Sleep(500);
	}
	CloseHandle(myHSemaphore);
	return TRUE;
}

进程2测试代码如下：

#include <Windows.h>
#include <iostream>
/*********************1 共享内存**********************/
HANDLE myHMutex;
HANDLE myHEvent;
BOOL SharedMemoryFun();
/*********************2 命名管道**********************/
#define MY_PIPE_NAME "\\\\.\\pipe\\mypipe"
BOOL PipeFun();
/*********************3 信号量************************/
HANDLE myHSemaphore;
BOOL SemaphoreFun();
int main()
{
	/*if (SharedMemoryFun() == FALSE)
	{
	std::cout<<"SharedMemoryFun ERROR"<<std::endl;
	}*/

	/*if (PipeFun() == FALSE)
	{
		std::cout<<"PipeFun ERROR"<<std::endl;
	}*/

	if (SemaphoreFun() == FALSE)
	{
		std::cout<<"SemaphoreFun ERROR"<<std::endl;
	}
	system("pause");
	return 0;
}

BOOL SharedMemoryFun()
{
	//打开共享文件句柄
	HANDLE myhandle = OpenFileMapping(FILE_MAP_ALL_ACCESS,
		FALSE,
		"MYSM");//共享文件名称
	if (myhandle == NULL)
	{
		return FALSE;
	}

	//映射
	LPVOID lpbuf = MapViewOfFile(myhandle, 
		FILE_MAP_ALL_ACCESS,
		0,
		0,
		0);
	if (lpbuf == NULL)
	{
		return FALSE;
		CloseHandle(myhandle);
	}

	myHMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "MYMUTEX");
	if (myHMutex == NULL)
	{
		return FALSE;
	}

	myHEvent = OpenEvent(EVENT_ALL_ACCESS, FALSE, "MYEVENT");
	if (myHEvent == NULL)
	{
		return FALSE;
	}

	while(TRUE)
	{
		char buf[128];
		std::cout<<"************* Message**********************"<<std::endl;
		
		WaitForSingleObject(myHEvent, INFINITE);
		WaitForSingleObject(myHMutex, INFINITE);

		memcpy(buf, lpbuf, strlen(buf)+1);
		ReleaseMutex(myHMutex);
		if (buf[0] == 'q')
		{
			break;
		}

		/*if (buf[0] == '1')
		{
			for (int i = 0; i < 100; i++)
			{
				std::cout<<"*******************************"<<std::endl;
			}
		}*/
		std::cout<<buf<<std::endl;
	}


	CloseHandle(myHEvent);
	CloseHandle(myHMutex);

	UnmapViewOfFile(lpbuf);
	CloseHandle(myhandle);
	return TRUE;
}

BOOL PipeFun()
{
	if (!WaitNamedPipe(MY_PIPE_NAME, NMPWAIT_USE_DEFAULT_WAIT))
	{
		return FALSE;
	}

	HANDLE myHPipe = CreateFile(MY_PIPE_NAME,
		GENERIC_READ | //对象的访问方式：读访问
		GENERIC_WRITE, //对象的访问方式：写访问
		0, //对象是否共享：0表示不共享
		NULL, //指向一个SECURITY_ATTRIBUTES结构的指针
		OPEN_EXISTING, //对象的创建方式：OPEN_EXISTING表示打开对象(管道)
		FILE_ATTRIBUTE_NORMAL, //设置对象的属性和标志
		NULL);

	if (myHPipe == INVALID_HANDLE_VALUE)
	{
		return FALSE;
	}

	while (TRUE)
	{
		char rbuf[128];
		DWORD rs;
		if (!ReadFile(myHPipe, rbuf, 128, &rs, NULL))
		{
			std::cout<<"ReadFile"<<std::endl;
		}
		else
		{
			std::cout<<rbuf<<std::endl;
		}

		char wbuf[128];
		std::cout<<"*************Send Message**********************"<<std::endl;
		std::cin.getline(wbuf, 128);
		DWORD wr;
		if (!WriteFile(myHPipe, wbuf, 128, &wr, NULL))
		{
			std::cout<<"WriteFile"<<std::endl;
		}		

	}

	CloseHandle(myHPipe);
	return TRUE;
}

BOOL SemaphoreFun()
{

	myHSemaphore = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE,"MYSEM");
	if(myHSemaphore == NULL)
	{
		return FALSE;
	}
	std::cout<<"waiting "<<std::endl;

	WaitForSingleObject(myHSemaphore, INFINITE);

	std::cout<<"had waited "<<std::endl;
	CloseHandle(myHSemaphore);

	return TRUE;
}