精华内容
下载资源
问答
  • C++ 进程间通信

    万次阅读 多人点赞 2019-05-31 16:58:30
    一,C++ 常用进程间通信 管道(Pipe):管道可用于具有亲缘关系进程间通信,允许一个进程和另一个与它有共同祖先的进程之间进行通信。 命名管道(namedpipe):命名管道克服了管道没有名字的限制,因此,除具有管道...

    一,C++ 常用进程间通信

    • 管道(Pipe):管道可用于具有亲缘关系进程间的通信,允许一个进程和另一个与它有共同祖先的进程之间进行通信。
    • 命名管道(named pipe):命名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。
    • 信号(Signal):信号是比较复杂的通信方式,用于通知接受进程有某种事件发生,除了用于进程间通信外,进程还可以发送信号给进程本身;Linux除了支持Unix早期信号语义函数sigal外,还支持语义符合Posix.1标准的信号函数sigaction(实际上,该函数是基于BSD的,BSD为了实现可靠信号机制,又能够统一对外接口,用sigaction函数重新实现了signal函数)。
    • 消息(Message)队列:消息队列是消息的链接表,包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息,被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少,管道只能承载无格式字节流以及缓冲区大小受限等缺
    • 共享内存:使得多个进程可以访问同一块内存空间,是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制,如信号量结合使用,来达到进程间的同步及互斥。
    • 信号量(semaphore):主要作为进程间以及同一进程不同线程之间的同步手段。
    • 套接字(Socket):更为一般的进程间通信机制,可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的,但现在一般可以移植到其它类Unix系统上:Linux和System V的变种都支持套接字。

    二,共享内存

    1. 共享内存是最快的一种 IPC,因为进程是直接对内存进行存取。
    2. 因为多个进程可以同时操作,所以需要进行同步。

    3. 信号量+共享内存通常结合在一起使用,信号量用来同步对共享内存的访问。

    // boosttest.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    
    #include <boost/lexical_cast.hpp>       
    #include <iostream>
    #include <boost/interprocess/shared_memory_object.hpp>
    #include <boost/interprocess/mapped_region.hpp>
    
    using namespace std;
    using namespace boost::interprocess;
    
    int main(int argc,char *argv[])
    {
    	cout << "argc" << argc<<argv[0];
    	if (argc == 1) {//父进程
    		//1 删除共享内存
    		struct  shm_remove
    		{
    			shm_remove() { shared_memory_object::remove("SharedMemory"); }
    			~shm_remove() { shared_memory_object::remove("SharedMemory"); }
    		}remover;
    
    
    	//2 创建共享内存段
    	shared_memory_object shm(create_only, "SharedMemory", read_write);
    
    	//3 设置共享内存大小
    	shm.truncate(100);
    
    	//4 映射共享内存片段
    	mapped_region region(shm, read_write);
    
    	//5 初始化为1
    	std::memset(region.get_address(), 1, region.get_size());
    	
    	//运行子进程
    	std::string s(argv[0]);
    	s += " child ";
    	if (0 != std::system(s.c_str()))
    		return 1;
    	}
    	else
    	{
    		//1 创建共享内存
    		shared_memory_object shm(open_only, "SharedMemory", read_only);
    
    		//2 映射共享内存
    		mapped_region region(shm, read_only);
    
    		//3 检查共享内存是否被初始化为1
    		char* mem = static_cast<char*>(region.get_address());
    		for (std::size_t i = 0; i < region.get_size(); ++i) {
    			if (*mem++ != 1)
    				return 1;
    			else
    			{
    				printf("mem:%d   ", *mem);
    			}
    		}
    	}
    
    	system("pause");
    	return 0;
    }

    三,消息队列

    1. 消息队列是面向记录的,其中的消息具有特定的格式以及特定的优先级。

    2. 消息队列独立于发送与接收进程。进程终止时,消息队列及其内容并不会被删除。

    3. 消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

    // boosttest.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    
    #include <boost/lexical_cast.hpp>       
    #include <iostream>
    #include <boost/interprocess/shared_memory_object.hpp>
    #include <boost/interprocess/mapped_region.hpp>
    #include <boost/interprocess/ipc/message_queue.hpp>
    #include <vector>
    
    using namespace std;
    using namespace boost::interprocess;
    
    int main(int argc,char *argv[])
    {
    	cout << "argc" << argc<<argv[0];
    	if (argc == 1) {//父进程
    		//1 删除消息队列
    		message_queue::remove("message_queue");
    
    	//2 创建消息队列
    		message_queue mq(create_only, "message_queue", 100, sizeof(int));
    
    	//3 发送100个数字
    		for (int i = 0; i < 100; ++i) {
    			mq.send(&i, sizeof(i), 0);
    	}
    	
    	//运行子进程
    	std::string s(argv[0]);
    	s += " child ";
    	if (0 != std::system(s.c_str()))
    		return 1;
    	}
    	else
    	{
    		//1 打开消息队列
    		message_queue mq(open_only, "message_queue");
    
    		unsigned int priority;
    		message_queue::size_type recvd_size;
    		for (int i = 0; i < 100; i++)
    		{
    			int number;
    			mq.receive(&number, sizeof(number),recvd_size,priority);
    			if (number != i || recvd_size != sizeof(number))
    				return 1;
    			else
    				printf("number:%d ", number);
    		}
    		
    		message_queue::remove("message_queue");
    	}
    
    	system("pause");
    	return 0;
    }

    四,信号量

    1. 信号量用于进程间同步,若要在进程间传递数据需要结合共享内存。

    2. 信号量基于操作系统的 PV 操作,程序对信号量的操作都是原子操作。

    3. 每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1,而且可以加减任意正整数。

    4. 支持信号量组。

    // boosttest.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    
    // boosttest.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    
    #include <boost/lexical_cast.hpp>       
    #include <iostream>
    #include <boost/interprocess/shared_memory_object.hpp>
    #include <boost/interprocess/mapped_region.hpp>
    #include <boost/interprocess/sync/interprocess_semaphore.hpp>
    
    using namespace std;
    using namespace boost::interprocess;
    
    struct  shared_memory_buffer
    {
    	enum { NumItems = 100};//数组大小
    	shared_memory_buffer():mutex(1),nempty(NumItems),nstored(0){}
    
    		interprocess_semaphore mutex, nempty, nstored;//匿名信号量
    		int items[NumItems];//共享数组
    };
    int main(int argc, char *argv[])
    {
    	//cout << "argc" << argc << argv[0];
    	if (argc == 1) {//父进程
    		//1 删除共享内存
    		struct  shm_remove
    		{
    			shm_remove() { shared_memory_object::remove("SharedMemory"); }
    		}remover;
    
    
    		//2 创建共享内存段
    		shared_memory_object shm(create_only, "SharedMemory", read_write);
    
    		//3 设置共享内存大小
    		shm.truncate(sizeof(shared_memory_buffer));
    
    		//4 映射共享内存片段
    		mapped_region region(shm, read_write);
    
    		//5 写数据,数据满了会阻塞
    		void *addr = region.get_address();
    		shared_memory_buffer *data = new(addr)shared_memory_buffer;
    		const int NumMsg = 100;
    		for (int i = 0; i < NumMsg; ++i) {
    			data->nempty.wait();
    			data->mutex.wait();
    			data->items[i%shared_memory_buffer::NumItems] = i;
    			data->mutex.post();
    			data->nstored.post();
    		}
    	}
    	else
    	{
    		struct shm_remove
    		{
    			~shm_remove() { shared_memory_object::remove("MySharedMemory"); }
    		} remover;
    
    		//1 创建共享内存
    		shared_memory_object shm(open_only, "SharedMemory", read_write);
    
    		//2 映射共享内存
    		mapped_region region(shm, read_write);
    
    		//3 共享数据复制到自己的缓冲
    		void * addr = region.get_address();
    		shared_memory_buffer* data = static_cast<shared_memory_buffer*>(addr);
    		const int NumMsg = 100;
    		int extracted_data[NumMsg];
    
    		for (int i = 0; i < NumMsg; ++i) {
    			data->nstored.wait();
    			data->mutex.wait();
    			extracted_data[i] = data->items[i%shared_memory_buffer::NumItems];
    			printf("data:%d ", data->items[i%shared_memory_buffer::NumItems]);
    			data->mutex.post();
    			data->nempty.post();
    		}
    	}
    
    	system("pause");
    	return 0;
    }

    信号量与互斥锁的区别:

    1,作用域

    信号量: 进程间或线程间(linux仅线程间)

    互斥锁: 线程间

    2,上锁时

    信号量: 只要信号量的value大于0,其他线程就可以wait成功,成功后信号量的value减一。若value值不大于0,则wait阻塞,直到post释放后value值加一

    互斥锁: 只要被锁住,其他任何线程都不可以访问被保护的资源

     

    参考:https://zhidao.baidu.com/question/1051708411830978339.html

    https://www.cnblogs.com/ltm5180/p/4334522.html

    http://blog.sina.com.cn/s/blog_a9cdad020102wy0e.html

    https://blog.csdn.net/everysmile/article/details/50573668

    https://www.cnblogs.com/zgq0/p/8780893.html

     

    展开全文
  • C#与C++进程间通信

    2021-05-27 11:13:29
    C#与C++进程间通信 PS:也是从网上各个帖子中学习的代码,因此代码的格式以及内容有粘贴网上其他大神的代码,如有侵权请告知删除 方式:管道 C++端代码: HANDLE hPipe; DWORD dwWrite; char Buffer[256]; //创建...

    C#与C++进程间通信

    PS:也是从网上各个帖子中学习的代码,因此代码的格式以及内容有粘贴网上其他大神的代码,如有侵权请告知删除

    方式:管道

    C++端代码:

    HANDLE hPipe;
    DWORD dwWrite;
    char Buffer[256];
    
    //创建管道
    hPipe = CreateNamedPipe(TEXT("\\\\.\\Pipe\\TEST"),
    				PIPE_ACCESS_DUPLEX, //双向管道
    				PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, //消息形式写入|消息形式读出|同步操作在等待的时候挂起线程
    				1, //最大客户端数
    				0, //输出缓冲区长度,0代表默认
    				0, //输入缓冲区长度,0代表默认
    				NMPWAIT_WAIT_FOREVER, //一直阻塞
    				0);
    if (hPipe == NULL)
    {
    	DWORD dWErr = GetLastError();
    	cout<<"Create Pipe,Error:"<<dWErr<<endl;
    }
    
    //等待连接
    if (ConnectNamedPipe(hPipe, NULL) != NULL)
    {
    }
    else
    {
    	DWORD dWErr = GetLastError();
    	cout<<"Connect Pipe,Error:"<<dWErr<<endl;
    }
    
    //发送数据
    sprintf(Buffer, "Send Message Test\n");
    if (!WriteFile(hPipe, Buffer, strlen(Buffer), &dwWrite, NULL))
    {
    	cout<<"Write Pipe Error"<<endl;
    }
    
    //关闭管道和句柄
    DisconnectNamedPipe(hPipe);
    CloseHandle(hPipe);
    

    C#端代码

    StreamReader sr = null;
    string Info;
    
    //创建管道
    NamedPipeClientStream Client = new NamedPipeClientStream("LocalHost", "TEST", PipeDirection.InOut, PipeOptions.Asynchronous, System.Security.Principal.TokenImpersonationLevel.None);
    
    //连接管道
    Client.Connect();
    sr = new StreamReader(Client);
    
    //接收数据
    Info = sr.ReadLine();
    
    
    展开全文
  • c++ 进程间通信实例

    2021-03-06 21:17:24
    1. windows下共享内存实现进程间通信 发送数据进程 #include <iostream> #include <Windows.h> using namespace std; #define BUF_SIZE 1024 HANDLE H_Mutex = NULL; HANDLE H_Event = NULL; int main...

    1. windows下共享内存实现进程间通信

    发送数据进程

    #include <iostream>
    #include <Windows.h>
    
    using namespace std;
    #define BUF_SIZE 1024
    HANDLE H_Mutex = NULL;
    HANDLE H_Event = NULL;
    int main()
    {
    	// 创建共享文件句柄
    	HANDLE shareFileHandle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, BUF_SIZE, "SharedMem");
    	if (shareFileHandle == NULL)
    	{
    		cout << "could not create file mapping object..." << endl;
    		return 1;
    	}
    
    	//映射缓冲区视图,得到指向共享内存的指针
    	LPVOID lpBuf = MapViewOfFile(shareFileHandle, FILE_MAP_ALL_ACCESS, 0, 0, BUF_SIZE);
    	if (lpBuf == NULL)
    	{
    		cout << "mapping view failed." << endl;
    		CloseHandle(shareFileHandle);
    		return 1;
    	}
    
    	// 创建一个互斥器
    	H_Mutex = CreateMutex(NULL, FALSE, "sm_mutex");
    	H_Event = CreateEvent(NULL, FALSE, FALSE, "sm_event");
    
    	// 操作共享内存
    	char buff[128] = {};
    	while (true)
    	{
    		cout << "A proccess:Please input the content to the process B" << endl;
    		cin.getline(buff, 128);
    		cout << "Buffer: " << buff << endl;
    		WaitForSingleObject(H_Mutex, INFINITE); //使用互斥体加锁   获得互斥器的拥有权
    		memcpy(lpBuf, buff, strlen(buff) + 1);
    		ReleaseMutex(H_Mutex); //放锁
    		SetEvent(H_Event); // 激活等待的进程
    	}
    	CloseHandle(H_Mutex);
    
    	CloseHandle(H_Event);
    
    
    	// 解除映射和关闭句柄
    	UnmapViewOfFile(lpBuf);
    	CloseHandle(shareFileHandle);
    	return 0;
    }
    

    接收数据进程

    #include <iostream>
    #include <Windows.h>
    
    using namespace std;
    HANDLE H_Mutex = NULL;
    HANDLE H_Event = NULL;
    
    int main()
    {
    	//步骤1:打开共享文件句柄
    
    	HANDLE sharedFileHandle = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, "SharedMem");
    	if (sharedFileHandle == NULL)
    	{
    		cout << "Could not open file mapping object..." << endl;
    		return 1;
    	}
    
    	//步骤2:映射缓存区视图,得到指向共享内存的指针
    	LPVOID lpBuf = MapViewOfFile(sharedFileHandle, FILE_MAP_ALL_ACCESS, 0, 0, 0);
    	if (lpBuf == NULL)
    	{
    		cout << "Could not create file mapping object..." << endl;
    		CloseHandle(sharedFileHandle);
    		return 1;
    	}
    	H_Event = OpenEvent(EVENT_ALL_ACCESS, FALSE, "sm_event");
    	if (H_Event == NULL)
    	{
    		cout << "open mutex failed..." << endl;
    		return 1;
    	}
    
    	char buffer[128];
    
    	//步骤3:操作共享内存
    
    	while (1)
    	{
    		cout << "B proccess:Receive data from process A" << endl;
    		WaitForSingleObject(H_Event, INFINITE);
    		WaitForSingleObject(H_Mutex, INFINITE); //使用互斥体加锁
    		memcpy(buffer, lpBuf, strlen((char *)lpBuf) + 1);
    
    		ReleaseMutex(H_Mutex); //放锁
    
    		cout << buffer << endl;
    
    		//system("PAUSE ");
    
    	}
    	CloseHandle(H_Event);
    	CloseHandle(H_Mutex);
    	//步骤4:解除映射和关闭句柄
    	UnmapViewOfFile(lpBuf);
    	CloseHandle(sharedFileHandle);
    	return 0;
    }
    

    运行效果

    在这里插入图片描述

    展开全文
  • C++ 进程间通信方式 1,共享内存; 2,管道; 3,信号量 进程1测试代码如下: #include <Windows.h> #include <iostream> /*********************1 共享内存**********************/ HANDLE myHMutex; ...

    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;
    }
    
    展开全文
  • C++共享内存进程间通信 FileMapping用于进程间快速通信
  • C++ 进程间通信详解

    2021-06-22 15:03:54
    一,C++ 常用进程间通信 管道(Pipe):管道可用于具有亲缘关系进程间通信,允许一个进程和另一个与它有共同祖先的进程之间进行通信。 命名管道(namedpipe):命名管道克服了管道没有名字的限制,因此,除具有管道...
  • linux下进程间通信的几种主要手段简介: 管道(Pipe)及有名管道(namedpipe):管道可用于具有亲缘关系进程间通信,有名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关系进程...
  • C++进程间通信的4中方式

    千次阅读 2016-12-30 16:22:53
    C++进程间通信进程间通讯的四种方式:剪贴板、匿名管道、命名管道和邮槽剪切板
  • c++进程间通信程序

    2012-03-24 22:57:52
    此代码为c++进程间通信的一个完整实例,代码编译后就可以运行,通过这个实例,可以掌握c++进程间通信知识
  • 2.进程间通信 2.1进程 本章讲解windows平台下,进程间通信方式。 进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动,是操作系统动态执行的基本单元。简单的说,进程就是一段程序的执行过程。 ...
  • C++进程间通信之SendMessage和PostMessage

    千次阅读 2019-04-28 10:27:48
    C++进程通信之SendMessage和PostMessage1,使用介绍2,需要注意的地方3,WM_COPYDATA的原理      SendMessage和PostMessage在Win32编程中是很常见的,主要是用来发送消息到指定的窗口,...
  • C++进程间通信方式

    2019-05-09 20:34:00
    进程通常被定义为一个正在运行的程序的实例,它由两个部分组成: 一个是操作系统用来管理进程的内核对象。内核对象也是系统用来存放关于进程的统计信息的地方 另一个是地址空间,它包含所有的可执行模块或DLL模块...
  • C++进程间通信---自定义消息

    千次阅读 2016-12-16 15:19:41
    在windows中消息分为两种,即系统消息和用户自定义消息,系统消息定义从0到0x3ff,可以使用0x400到0x7fff定义自己的消息。windows把0x400定义为WM_USER,如果想...要想用消息实现进程间通信,则需要在这两个程序中定义
  • 消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法。 每个数据块都被认为含有一个类型,接收进程可以独立地接收含有不同类型的数据结构。我们可以通过发送消息来避免命名管道的同步和阻塞问题。但是...
  • C++进程间通信方法比较

    千次阅读 2016-12-19 17:41:05
    C++进程间通信方法比较
  • 1. 基于套接字的通信[集群案例] 现在的集群通常就是基于套接字的,集群的概念就是存在一个中央服务器,A,以及工作服务器B,C,D,E 一开始,BCDE会和A建立连接 其中B是注册,C是登录 玩家进入游戏后,直接和E进行交流...
  • C++进程间通信的十一种方法

    千次阅读 2018-12-27 16:11:08
    进程通常被定义为一个正在运行的程序的实例,它由两个部分组成: 一个是操作系统用来管理进程的内核对象。内核对象也是系统用来存放关于进程的统计信息的地方 另一个是地址空间,它包含所有的可执行模块或DLL模块的...
  • C++ 进程间通讯

    千次阅读 2012-10-30 21:40:46
    当一个进程启动的时候.操作系统会为这个进程分配4GB的私有地址空间供这个进程使用.在一个进程中的多个线程,共享同一个地址空间.因此线程间的通讯非常简单....进程间通讯的四种方试: 1.剪切板  剪切板实际上
  • mfc vc++ 进程通信 消息传递 mfc vc++ 进程通信 消息传递 mfc vc++ 进程通信 消息传递
  • c++ 进程间通信

    热门讨论 2009-10-22 00:32:19
    c++ 进程间通信 四种方式:剪贴板 匿名管道 命名管道 邮槽
  • } 上面c++和python进程通信收发可以互换,实现c++c++或python之间的进程通信。 open默认是阻塞的,参考https://www.cnblogs.com/52php/p/5840229.html 非阻塞我想一个应用是可以用于定时器查询。 fork启动第一...
  • 本实例利用匿名管道技术实现多进程之间的通信,实现了进程之间的发送数据和接收数据。
  • } //子进程 if(0==pid) { close(fd[1]); memset(buf,0,SIZE); //读管道 ret=read(fd[0],buf,SIZE); if(ret) { perror("read"); exit(-1); } printf("child process buf:%s\n",buf); close(fd[0]); exit(0); }; //父...
  • 刚刚测试的延迟从Java在我的Corei5 2.8GHz,只有单字节发送/接收,2 Java进程刚刚生成,没有为任务分配特定的CPU核心:TCP - 25 microsecondsNamed pipes - 15 microseconds现在明确指定核心掩码,如taskset 1 java ...
  • 进程同步的方法 1、互斥量(Mutex):为协调共同对一个共享资源的单独访问而设计的。 2、信号量(Semaphore):现和纠正。 3、事件(Event): 线程同步的方法: 1:临界区 2:锁 3:信号量 4:事件 ...
  • http://blog.csdn.net/ezhchai/article/details/74992980文章中讲解的示例程序完整工程文件
  • windows C++进程间和线程间通信

    千次阅读 2016-08-09 21:36:15
    Thank Swarajya Pendharkar and MSDN...进程间通信进程基本概念In computer science, inter-process communication or interprocess communication (IPC) refers specifically to the mechanisms an operating system p
  • RCF-3.2.413--进程通信开源库--进程开发--最新版本
  • 文件中包含文件的拷贝方法,多进程的基础概念,相关函数的用法,队列的先进先出,共享内存等内容。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,517
精华内容 25,406
关键字:

c++进程间通讯

c++ 订阅