精华内容
下载资源
问答
  • C++进程通信之匿名管道
    千次阅读
    2016-12-19 11:17:51

    匿名管道只能用来实现同一台机器上父子进程间通信,而不能实现跨网络的通信。

    利用匿名管道实现父子进程通信时,需要注意:因为匿名管道没有名称,所以只能在父进程中调用Createprocess函数创建子线程时,将管道的读写句柄传递给子线程。


    1.父进程代码

    private:
    	HANDLE  m_hRead;//匿名管道读句柄
    	HANDLE  m_hWrite;//匿名管道写句柄


    void CParentView::OnPipeCreate()
    {
    	SECURITY_ATTRIBUTES sa;//定义安全结构体
    	sa.bInheritHandle = TRUE;//可以被子进程所继承
    	sa.lpSecurityDescriptor = NULL;
    	sa.nLength = sizeof(SECURITY_ATTRIBUTES);
    
    	if (!CreatePipe(&m_hRead, &m_hWrite, &sa, 0))//创建管道
    	{
    		MessageBox("创建管道失败!");
    		return;
    	}
    
    	STARTUPINFO sui;
    	PROCESS_INFORMATION pi;
    	ZeroMemory(&sui, sizeof(STARTUPINFO));
    	sui.cb = sizeof(STARTUPINFO);
    	sui.dwFlags = STARTF_USESTDHANDLES;
    	sui.hStdInput = m_hRead;//设置子进程的标准输入句柄为管道读句柄
    	sui.hStdOutput = m_hWrite;//设置子进程的标准输出句柄为管道写句柄
    	sui.hStdError = GetStdHandle(STD_ERROR_HANDLE);//设置子进程的错误句柄为父进程错误句柄
    
    	if (!CreateProcess("..\\..\\Child\\Debug\\Child.exe", NULL, NULL, NULL, TRUE, 0, NULL, NULL, &sui, &pi))//创建子进程
    	{
    		CloseHandle(m_hRead);
    		CloseHandle(m_hWrite);
    		m_hRead = NULL;
    		m_hWrite = NULL;
    		MessageBox("创建子进程失败!");
    		return;
    	}
    	else
    	{
    		CloseHandle(pi.hProcess);//子进程内核对象计数减1
    		CloseHandle(pi.hThread);//子进程主线程内核对象计数减1
    	}
    
    }
    
    
    void CParentView::OnPipeRead()
    {
    	char buf[100];
    	DWORD dwRead;
    	if (!ReadFile(m_hRead,buf,100,&dwRead,NULL))//利用匿名管道的读句柄从管道中读取数据
    	{
    		MessageBox("读取数据失败!");
    		return;
    	}
    	else
    	{
    		MessageBox(buf);
    	}
    }
    
    
    void CParentView::OnPipeWrite()
    {
    	char buf[]="dadadadakai";
        DWORD dwWrite;
    	if (!WriteFile(m_hWrite,buf,strlen(buf)+1, &dwWrite, NULL))//利用匿名管道的写句柄从管道中写入数据
    	{
    		MessageBox("写入数据失败!");
    		return;
    	}
    }

    2.子进程代码

    private:
    	HANDLE   m_hRead;//匿名管道读句柄
    	HANDLE   m_hWrite;//匿名管道写句柄


    void CChildView::OnInitialUpdate()
    {
    	CView::OnInitialUpdate();
    
    	m_hRead = GetStdHandle(STD_INPUT_HANDLE);//获取标准输入句柄
    	m_hWrite = GetStdHandle(STD_OUTPUT_HANDLE);//获取标准输出句柄
    }
    
    
    void CChildView::OnPipeRead()
    {
    	char buf[100];
    	DWORD dwRead;
    	if (!ReadFile(m_hRead, buf, 100, &dwRead, NULL))//使用标准输入句柄(即匿名管道读句柄)读取数据
    	{
    		MessageBox("读取数据失败!");
    		return;
    	}
    	MessageBox(buf);
    }
    
    
    void CChildView::OnPipeWrite()
    {
    	char buf[]="yyyyyyxue";
    	DWORD dwWrite;
    	if (!WriteFile(m_hWrite, buf, strlen(buf)+1, &dwWrite, NULL))//使用标准输出句柄(即匿名管道写句柄)写入数据
    	{
    		MessageBox("写入数据失败!");
    		return;
    	}
    }



    更多相关内容
  • C++共享内存进程通信 FileMapping用于进程间快速通信
  • 项目研发过程中用到了进程通信,由C++应用程序创建共享内存及两个同步事件(Event1、Event2),然后阻塞等待外部进程激活事件Event1,Event1激活后,C++应用程序读取共享内存中的数据,完成数据解析后执行相应指令,并...

    项目研发过程中用到了进程通信,由C++应用程序创建共享内存及两个同步事件(Event1、Event2),然后阻塞等待外部进程激活事件Event1,Event1激活后,C++应用程序读取共享内存中的数据,完成数据解析后执行相应指令,并向共享内存中写入指令执行结果,同时激活事件Event2;而Python进程则负责打开共享内存和两个同步事件,向共享内存中写入数据,并激活Event1,然后阻塞等待Event2被激活,Event2激活后,读取共享内存中的数据。进程通讯关系如下图所示:

    C++程序源码如下:

     

    DWORD WINAPI IPC_ReadExecuteCmd(LPVOID lpParameter)
    {
    	unsigned long buff_size = IPC_BufferSize;
    	ControlCmdPara ReceiveData;
    	memset(&ReceiveData, 0, sizeof(ReceiveData));
    	ControlCmdPara SendData;
    	memset(&SendData, 0, sizeof(SendData));
    	HANDLE file_shared_handler = CreateFile(L"shared_memory",
    		GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    	if (file_shared_handler == INVALID_HANDLE_VALUE)
    		cout << "create file error" << endl;
    	HANDLE file_mapping_handler = CreateFileMapping(file_shared_handler, NULL, PAGE_READWRITE, 0, buff_size, L"shared_memory");
    	if (file_mapping_handler == INVALID_HANDLE_VALUE)
    		cout << "create file_mapping error" << endl;
    	LPVOID lp_base = MapViewOfFile(file_mapping_handler, FILE_MAP_ALL_ACCESS, 0, 0, 0);
    	if (lp_base == INVALID_HANDLE_VALUE)
    		cout << "MapViewOfFile error" << endl;
    	HANDLE m_hEvent = CreateEvent(NULL, FALSE, FALSE, GLOBAL_EVENT_NAME);
    	if (m_hEvent == nullptr)
    		cout << "create Event error";
    	HANDLE WaitEvent = CreateEvent(NULL, FALSE, FALSE, GLOBAL_EVENT_WAIT);
    	if (WaitEvent == nullptr)
    		cout << "create WaitEvent error";
    	CString IPC_Cmd, strScriptKeyWord, strParameter;
    	LRESULT lScriptCmdResult = 0;
    	while (true)
    	{
    		WaitForSingleObject(m_hEvent, INFINITE);
    		memcpy(&ReceiveData, lp_base, buff_size);
    		/* 调用API执行指令*/
    		IPC_Cmd = string(ReceiveData.Cmd).substr(0, 15).c_str();
    		strScriptKeyWord = string(ReceiveData.YjksCmd).substr(0, 31).c_str();
    		strParameter = string(ReceiveData.Para).substr(0, 975).c_str();
    		strScriptKeyWord.TrimRight();
    		strParameter.TrimRight();
    		IPC_Cmd.TrimRight();
    		string ResaultStr = "Success";
    		strcpy(SendData.Cmd, "Result");
    		if (!IPC_Cmd.CompareNoCase(PLAYBACK))
    		{
    			lScriptCmdResult = IPC_ExecuteScrCmd(strScriptKeyWord, strParameter);
    		}
    		if (!IPC_Cmd.Compare(RECORD))
    		{
    			lScriptCmdResult = IPC_ExecuteScrCmd(L"_makescript", L"");
    		}
    		if (lScriptCmdResult < 0) ResaultStr = "Failure";
    		strcpy(SendData.Para, ResaultStr.c_str());
    		memcpy(lp_base, &SendData, buff_size);
    		if (WaitEvent != nullptr) SetEvent(WaitEvent);
    	}
    	FlushViewOfFile(lp_base, buff_size);
    	UnmapViewOfFile(lp_base);
    	CloseHandle(file_mapping_handler);
    	CloseHandle(file_shared_handler);
    	return 0;
    }

    Python程序源码如下:

    from ctypes import *
    import mmap
    
    def IPC_CmdControl(IPC_Cmd,strScriptKeyWord,strParameter):
        print(windll.kernel32.GetLastError())
        buff_size = 1024
        EVENT_ALL_ACCESS = 0x000F0000|0x00100000|0x3
        shm = mmap.mmap(0, buff_size, "shared_memory")
        OpenEvent=windll.kernel32.OpenEventW
        m_hEvent = OpenEvent(2, True, "Global\\ShareMemoryEvent")
        WaitEvent = OpenEvent(EVENT_ALL_ACCESS, True, "Global\\WaitResaultEvent")
        strParameter = "\""+strParameter+"\"";
        if shm:
          shm[:] = b' ' * buff_size
          shm.seek(0)
          shm.write(bytes(IPC_Cmd, 'UTF-8'))
          shm.seek(16)
          shm.write(bytes(strScriptKeyWord, 'UTF-8'))
          shm.seek(48)
          shm.write(bytes(strParameter, 'UTF-8'))
          windll.kernel32.SetEvent(m_hEvent)
          windll.kernel32.WaitForSingleObject(WaitEvent,-1)
          shm.seek(48)
          return shm.read(7).rstrip()
    
    if __name__ == '__main__':
        IPC_CmdControl(IPC_Cmd,strScriptKeyWord,strParameter)

    展开全文
  • C++进程通信 详解2

    2021-05-24 10:45:56
    一、概述二、进程通信概念及方法1. 管道的概念2. pipe3. 管道的读写行为4. 管道缓冲区大小5. 管道优劣6. FIFO7. 共享存储映射8. mmap函数9. munmap函数10. mmap九问11. mmap父子进程通信12. 匿名映射13. mmap无...

    一、概述

    在这里插入图片描述

    二、进程间通信概念及方法

    Linux环境下,进程地址空间相互独立,每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到,所以进程和进程之间不能相互访问。

    要交换数据必须通过内核,在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为 进程间通信(IPC,InterProcess Communication)
    在这里插入图片描述
    在进程间完成数据传递需要借助操作系统提供特殊的方法,如:文件、管道、信号、共享内存、消息队列、套接字、命名管道等。随着计算机的蓬勃发展,一些方法由于自身设计缺陷被淘汰或者弃用。

    现今常用的进程间通信方式有:
    1)管道 (使用最简单)
    2)信号 (开销最小)
    3)共享映射区 (无血缘关系)
    4)本地套接字 (最稳定)


    进程间通信方法介绍

    1. 管道的概念

    管道是一种最基本的IPC机制,作用于 有血缘关系的进程之间,完成数据传递。调用pipe系统函数即可创建一个管道。

    有如下特质:
    1) 其本质是一个伪文件(实为内核缓冲区)
    2)由两个文件描述符引用,一个表示读端,一个表示写端。
    3) 规定数据从管道的写端流入管道,从读端流出。

    管道的原理: 管道实为内核使用环形队列机制,借助内核缓冲区(4k)实现。

    管道的局限性:
    1) 数据一旦被读走,便不在管道中存在,不可反复读取。
    2) 由于管道采用半双工通信方式。因此,数据只能在一个方向上流动。
    3) 只能在有公共祖先的进程间使用管道。

    常见的通信方式有,单工通信、半双工通信、全双工通信。

    2. pipe

    创建管道 int pipe(int pipefd[2]); 成功:0;失败:-1,设置errno

    函数调用成功,返回r/w两个文件描述符。无需open,但需手动close。

    规定:fd[0] → r; fd[1] → w,就像0对应标准输入,1对应标准输出一样。

    向管道文件读写数据其实是在读写内核缓冲区。管道创建成功以后,创建该管道的进程(父进程)同时掌握着管道的读端和写端。

    如何实现父子进程间通信呢?

    通常可以采用如下步骤:
    在这里插入图片描述

    1)父进程调用pipe函数创建管道,得到两个文件描述符fd[0]、fd[1]指向管道的读端和写端。
    2)父进程调用fork创建子进程,那么子进程也有两个文件描述符指向同一管道。
    3)父进程关闭管道读端,子进程关闭管道写端。父进程可以向管道中写入数据,子进程将管道中的数据读出。由于管道是利用环形队列实现的,数据从写端流入管道,从读端流出,这样就实现了进程间通信。

    练习:父子进程使用管道通信,父写入字符串,子进程读出并打印到屏幕?
    在这里插入图片描述
    在这里插入图片描述

    3. 管道的读写行为

    使用管道需要注意以下4种特殊情况(假设都是阻塞I/O操作,没有设置O_NONBLOCK标志):

    1)如果所有指向管道写端的文件描述符都关闭了(管道写端引用计数为0),而仍然有进程从管道的读端读数据,那么管道中剩余的数据都被读取后,再次read会返回0,就像读到文件末尾一样。
    2) 如果有指向管道写端的文件描述符没关闭(管道写端引用计数大于0),而持有管道写端的进程也没有向管道中写数据,这时有进程从管道读端读数据,那么管道中剩余的数据都被读取后,再次read会阻塞,直到管道中有数据可读了才读取数据并返回。
    3)如果所有指向管道读端的文件描述符都关闭了(管道读端引用计数为0),这时有进程向管道的写端write,那么该进程会收到信号SIGPIPE,通常会导致进程异常终止。当然也可以对SIGPIPE信号实施捕捉,不终止进程。具体方法信号章节详细介绍。
    4)如果有指向管道读端的文件描述符没关闭(管道读端引用计数大于0),而持有管道读端的进程也没有从管道中读数据,这时有进程向管道写端写数据,那么在管道被写满时再次write会阻塞,直到管道中有空位置了才写入数据并返回。

    总结:
    1)读管道:

    1. 管道中有数据,read返回实际读到的字节数。
    2. 管道中无数据:
      (1) 管道写端被全部关闭,read返回0 (好像读到文件结尾)
      (2) 写端没有全部被关闭,read阻塞等待(不久的将来可能有数据递达,此时会让出cpu)

    2)写管道:

    1. 管道读端全部被关闭, 进程异常终止(也可使用捕捉SIGPIPE信号,使进程不终止)
    2. 管道读端没有全部关闭:
      (1) 管道已满,write阻塞。
      (2) 管道未满,write将数据写入,并返回实际写入的字节数。

    练习1:使用管道实现父子进程间通信,完成:ls | wc -l。假定父进程实现ls,子进程实现wc?
    注意:

    • ls命令正常会将结果集写出到stdout,但现在会写入管道的写端;
    • wc -l 正常应该从stdin读取数据,但此时会从管道的读端读。

    实现父进程ls 子进程wc -l
    在这里插入图片描述
    在这里插入图片描述

    父子进程实现ps aux | grep bash
    在这里插入图片描述
    在这里插入图片描述

    练习2:使用管道实现兄弟进程间通信。 兄:ls 弟: wc -l 父:等待回收子进程?要求,使用“循环创建N个子进程”模型创建兄弟进程,使用循环因子i标示。
    注意管道读写行为。
    实现思路:父进程关闭读写端,两个子进程,一个关闭管道的读端去写,一个关闭管道的写端去读。

    兄弟进程间实现ls | wc -l
    在这里插入图片描述
    在这里插入图片描述
    兄弟进程实现ps aux | grep bash
    在这里插入图片描述
    在这里插入图片描述


    测试:是否允许,一个pipe有一个写端多个读端呢?是否允许有一个读端多个写端呢?

    • 一写多读
      结论:一个读多个写会hang住。
    • 多写一读
      结论:一个写多个读会hang住。

    4. 管道缓冲区大小

    可以使用ulimit -a 命令来查看当前系统中创建管道文件所对应的内核缓冲区大小。

    通常为:
    在这里插入图片描述
    也可以使用fpathconf函数,借助参数选项来查看。

    5. 管道优劣

    • 优点:简单,相比信号,套接字实现进程间通信,简单很多。
    • 缺点:
      1. 只能单向通信,双向通信需建立两个管道。
      2. 只能用于父子、兄弟进程(有共同祖先)间通信,该问题后来使用fifo有名管道解决。

    6. FIFO

    FIFO常被称为有名管道,以区分管道(pipe)。

    • 管道(pipe)只能用于“有血缘关系”的进程间。
    • 但通过FIFO,不相关的进程也能交换数据。

    FIFO是Linux基础文件类型中的一种。但FIFO文件在磁盘上没有数据块,仅仅用来标识内核中一条通道。各进程可以打开这个文件进行read/write,实际上是在读写内核通道,这样就实现了进程间通信。

    创建方式:

    1. 命令:mkfifo 管道名
    2. 库函数:int mkfifo(const char *pathname, mode_t mode); 成功:0; 失败:-1

    一旦使用mkfifo创建了一个FIFO,就可以使用open打开它,常见的文件I/O函数都可用于fifo,如:close、read、write、unlink等。

    fifo_w.c
    在这里插入图片描述
    fifo_r.c
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    注意:
    Opening the read or write end of a FIFO blocks until the other end is also opened (by another process or thread). See fifo(7) for further details.
    open注意事项,打开fifo文件的时候,read端会阻塞等待write端open,write端同理,也会阻塞等待另外一端打开。

    7. 共享存储映射

    (1)文件进程间通信

    使用文件也可以完成IPC,理论依据是,fork后,父子进程共享文件描述符,也就共享打开的文件。

    (2)存储映射IO

    存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据,就相当于读文件中的相应字节。于此类似,将数据存入缓冲区,则相应的字节就自动写入文件。这样,就可在不适用read和write函数的情况下,使用地址(指针)完成I/O操作。

    使用这种方法,首先应通知内核,将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。

    在这里插入图片描述

    8. mmap函数

    在这里插入图片描述 返回:

    • 成功:返回创建的映射区首地址;
    • 失败:MAP_FAILED宏

    参数:

    • addr:建立映射区的首地址,由Linux内核指定。使用时,直接传递NULL
    • length:欲创建映射区的大小
    • prot: 映射区权限PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE
    • flags:标志位参数(常用于设定更新物理区域、设置共享、创建匿名映射区)
    • MAP_SHARED: 会将映射区所做的操作反映到物理设备(磁盘)上。
    • MAP_PRIVATE: 映射区所做的修改不会反映到物理设备。
    • fd:用来建立映射区的文件描述符
    • offset:映射文件的偏移(4k的整数倍)

    9. munmap函数

    在这里插入图片描述
    同malloc函数申请内存空间类似的,mmap建立的映射区在使用结束后也应调用类似free的函数来释放。
    在这里插入图片描述
    在这里插入图片描述
    执行结果:

    执行map.c之前,mem.txt大小为30,代码中 ftruncate(fd,8); 将文件截断为8个字节大小,共享映射为20个字节,虽然文件大小(8) < 映射区大小(20),映射区可以存储helloworld(10),同时修改文件mem.txt内容。
    在这里插入图片描述
    借鉴malloc和free函数原型,尝试装自定义函数smalloc,sfree来完成映射区的建立和释放。思考函数接口该如何设计?

    10. mmap九问

    1. 如果更改mem变量的地址,释放的时候munmap,传入mem还能成功吗? 不能!!
    2. 如果对mem越界操作会怎么样? 文件的大小对映射区操作有影响,尽量避免。
    3. 如果文件偏移量随便填个数会怎么样? offset必须是4k的整数倍。
    4. 如果文件描述符先关闭,对mmap映射有没有影响?没有影响。
    5. open的时候,可以新创建一个文件来创建映射区吗?不可以用大小为0的文件。
    6. open文件选择O_WRONLY,可以吗? 不可以: Permission denied。
    7. 当选择MAP_SHARED的时候,open文件选择O_RDONLY,prot可以选择PROT_READ|PROT_WRITE吗?Permission denied ,SHARED的时候,映射区的权限 <= open文件的权限。
    8. mmap什么情况下会报错?很多情况。
    9. 如果不判断返回值会怎么样? 会死的很难堪!!

    总结:使用mmap时务必注意以下事项:

    1. 创建映射区的过程中,隐含着一次对映射文件的读操作。
    2. 当MAP_SHARED时,要求:映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓,因为mmap中的权限是对内存的限制。
    3. 映射区的释放与文件关闭无关。只要映射建立成功,文件可以立即关闭。
    4. 特别注意,当映射文件大小为0时,不能创建映射区。所以:用于映射的文件必须要有实际大小!! mmap使用时常常会出现总线错误,通常是由于共享文件存储空间大小引起的。
    5. munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作
    6. 文件偏移量必须为4K的整数倍
    7. mmap创建映射区出错概率非常高,一定要检查返回值,确保映射区建立成功再进行后续操作。

    11. mmap父子进程间通信

    父子等有血缘关系的进程之间也可以通过mmap建立的映射区来完成数据通信。但相应的要在创建映射区的时候指定对应的标志位参数flags:

    • MAP_PRIVATE: (私有映射) 父子进程各自独占映射区;
    • MAP_SHARED: (共享映射) 父子进程共享映射区;

    练习:父进程创建映射区,然后fork子进程,子进程修改映射区内容,而后,父进程读取映射区内容,查验是否共享。
    在这里插入图片描述
    在这里插入图片描述
    结论:

    父子进程共享:1. 打开的文件 2. mmap建立的映射区(但必须要使用MAP_SHARED)

    12. 匿名映射

    通过使用我们发现,使用映射区来完成文件读写操作十分方便,父子进程间通信也较容易。但缺陷是,每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要open一个temp文件,创建好了再unlink、close掉,比较麻烦。

    可以直接使用匿名映射来代替。其实Linux系统给我们提供了创建匿名映射区的方法,无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定。

    使用MAP_ANONYMOUS (或MAP_ANON), 如:

    int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0); 
    
      
    • 1

    需注意的是,MAP_ANONYMOUS和MAP_ANON这两个宏是Linux操作系统特有的宏。在类Unix系统中如无该宏定义,可使用如下两步来完成匿名映射区的建立。

    1)fd = open("/dev/zero", O_RDWR);
    2)p = mmap(NULL, size, PROT_READ|PROT_WRITE, MMAP_SHARED, fd, 0);
    
      
    • 1
    • 2

    在这里插入图片描述
    在这里插入图片描述

    13. mmap无血缘关系进程间通信

    实质上mmap是内核借助文件帮我们创建了一个映射区,多个进程之间利用该映射区完成数据传递。由于内核空间多进程共享,因此无血缘关系的进程间也可以使用mmap来完成通信。只要设置相应的标志位参数flags即可。若想实现共享,当然应该使用MAP_SHARED了。

    mmap_w.c
    在这里插入图片描述
    mmap_r.c
    在这里插入图片描述
    在这里插入图片描述

    3. 练习

    1. 通过命名管道传输数据,进程A和进程B,进程A将一个文件发送给进程B?

    file2fifo.c
    在这里插入图片描述
    fifo2file.c
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    1. 实现多进程拷贝文件?
      在这里插入图片描述
      在这里插入图片描述在这里插入图片描述在这里插入图片描述
    1 #include <stdio.h>
    2 #include <unistd.h>
    3 #include <sys/types.h>
    4 #include <fcntl.h>
    5 #include <sys/mman.h>
    6 #include <stdlib.h>
    7 #include <string.h>
    8 #include <sys/stat.h>
    9 #include <wait.h>
    10 int main(int argc, char *argv[])
    11 {
    12     //拷贝文件起的进程数,通过参数输入,默认是5个
    13     int n = 5;
    14     //输入参数至少是3,第4个参数是进程个数
    15     if (argc < 3)
    16     {
    17         printf("./a.out src dst [n]\n");
    18         return -1;
    19     }
    20     if (argc == 4)
    21     {
    22         n = atoi(argv[3]);
    23     }
    24 
    25     //打开源文件
    26     int srcfd = open(argv[1], O_RDONLY);
    27     if (srcfd < 0)
    28     {
    29         perror("open src err:");
    30         exit(1);
    31     }
    32 
    33     //打开目标文件
    34     int dstfd = open(argv[2], O_RDWR|O_CREAT|O_TRUNC, 0644);
    35     if (dstfd < 0)
    36     {
    37         perror("open dst err:");
    38         exit(1);
    39     }
    40 
    41     //目标拓展,从源文件获得文件大小,stat
    42     struct stat sb;
    43     stat(argv[1], &sb);
    44     //将目标文件设置为和源文件大小相同
    45     int len = sb.st_size;
    46     truncate(argv[2], len);
    47 
    48     //将源文件映射到缓冲区
    49     char *psrc = mmap(NULL, len, PROT_READ, MAP_SHARED, srcfd, 0);
    50     if (psrc == MAP_FAILED)
    51     {
    52         perror("mmap src err:");
    53         exit(1);
    54     }
    55 
    56     //将目标文件映射
    57     char *pdst = mmap(NULL, len, PROT_READ|PROT_WRITE, 
    						MAP_SHARED, dstfd, 0);
    58     if (pdst == MAP_FAILED)
    59     {
    60         perror("mmap pdst err:");
    61         exit(1);
    62     }
    63     //创建多个子进程
    64     int i = 0;
    65     for (i = 0; i < n; i++)
    66     {
    67         if (fork() == 0)
    68         {
    69             break;
    70         }
    71     }
    72     //计算子进程需要拷贝的起点大小
    73     int cpsize = len/n;
    74     int mod = len%n;
    75     //数据拷贝,memcpy
    76     if (i < n)
    77     {
    78         //最后一个子进程
    79         if (i == n-1)
    80         {
    81             memcpy(pdst+i*cpsize, psrc+i*cpsize, cpsize+mod);
    82         }
    83         else 
    84         {
    85             memcpy(pdst+i*cpsize, psrc+i*cpsize, cpsize);
    86         }
    87     }
    88     else
    89     {
    90         for (i = 0; i < n; i++)
    91         {
    92             //回收子线程
    93             wait(NULL);
    94         }
    95     }
    96     //释放映射区
    97     if (munmap(psrc, len) < 0)
    98     {
    99         perror("munmap src err:");
    100         exit(1);
    101     }
    102 
    103     if (munmap(pdst, len) < 0)
    104     {
    105         perror("munmap dst err:");
    106         exit(1);
    107     }
    108 
    109     //关闭文件
    110     close(srcfd);
    111     close(dstfd);
    112     
    113     return 0;
    114 }
    
      
    • 在这里插入图片描述

    展开全文
  • C++ 进程通信的方法

    千次阅读 2017-01-05 17:25:31
    进程通信基本方法有如下几种。 1、消息传递机制。 2、共享内存。 3、管道和邮槽。 4、剪贴板。 5、Socket通信。 1.消息传递机制 使用WM_COPYDATA实现进程间的传递数据。 函数原型 LRESULT SendMessage...
    进程通信基本方法有如下几种。
    1、消息传递机制。
    2、共享内存。
    3、管道和邮槽。
    4、剪贴板。
    5、Socket通信。

    1.消息传递机制
    使用WM_COPYDATA实现进程间的传递数据。
    函数原型
    LRESULT SendMessage(HWND hWnd,UINT Msg,WPARAM wParam,LPARAM IParam)
    参数
    hWnd:其窗口程序将接收消息的窗口的句柄。如果此参数为HWND_BROADCAST,则消息将被发送到系统中所有顶层窗口,包括无效或不可见的非自身拥有的窗口、被覆盖的窗口和弹出式窗口,但消息不被发送到子窗口。
    Msg:指定被发送的消息。
    wParam:指定附加的消息特定信息。
    IParam:指定附加的消息特定信息。
    返回值:返回值指定消息处理的结果,依赖于所发送的消息。

    其中lParam是一个结构指针。
    typedef struct tagCOPYDATASTRUCT {
      DWORD dwData; //数据标识
      DWORD cbData; //数据大小
      PVOID lpData; //具体数据
    } COPYDATASTRUCT;

    2.共享内存
    原理:一个进程创建内存映射,可以在多个进程中使用,这些进程共享一块内存。
    对应API。
    创建:HANDLE hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
    PAGE_READWRITE|SEC_COMMIT, 0, DEF_DATA_SIZE, “shareMemSample”);
    映射共享:lpData=MapViewOfFile(hMapFile, FILE_MAP_READ|FILE_MAP_WRITE,0,0,0);
    关闭共享:UnmapViewOfFile(lpData); CloseHandle(hMapFile);
    打开共享内存:
    hMapFile = OpenFileMapping(FILE_MAP_READ, FALSE, “shareMemSample”);
    lpBase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);

    3.管道和邮槽
    主要分为匿名管道、命名管道和邮槽。
    1、匿名管道:基于字符和单向的。CreatePipe。
    2、命名管道:双向的,面向字节流。CreateNamedPipe、ConnectNamedPipe。
    3、邮槽:单通道通信。CreateMailslot。

    4.剪贴板
    基本机制:由系统预留的一块全局共享内存,可用于被各进程暂时存储数据。
    主要API:OpenClipboard、EmptyClipboard、GetClipboardData、SetClipboardData、CloseClipboard。

    5.Socket通信
    Socket可以跨机器通信,自然可以支持跨进程通信。
    展开全文
  • 1. 同一主机上的进程通信 父子进程之间 非父子进程之间 2.不同主机上的进程通信(网络通信) 2. 普通文件通信 父子进程之间可以直接通过文件描述符号(fd)直接进行通信 示例: 父进程写文件,子进程读取文件 #...
  • 进程创建消息队列和两个子进程p1和p2 子进程p1打开给定文件(如果没有,则创建文件),并向文件中写数据,写完关闭文件,然后向消息队列写入一条消息“ok”,目的是通知进程p2可以读取文件内容了。 子进程p2从消息...
  • C#与C++进程通信

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

    千次阅读 2021-12-03 16:54:44
    管道不仅可以用于本机进程通信,还可实现跨网络进程通信,如同Socket通信,管道同样封装计算机底层网络实现,提供一个良好的API接口。 管道(Pipe)实际是用于进程通信的一段共享内存,创建管道的进程称为管道...
  • C++ 进程通信

    万次阅读 多人点赞 2019-05-31 16:58:30
    一,C++ 常用进程通信 管道(Pipe):管道可用于具有亲缘关系进程间的通信,允许一个进程和另一个与它有共同祖先的进程之间进行通信。 命名管道(namedpipe):命名管道克服了管道没有名字的限制,因此,除具有管道...
  • C++ 进程通信方式 1,共享内存; 2,管道; 3,信号量 进程1测试代码如下: #include <Windows.h> #include <iostream> /*********************1 共享内存**********************/ HANDLE myHMutex; ...
  • c++进程通信11种方法

    2013-12-13 10:42:06
    进程通常被定义为一个正在运行的程序的实例,它由两个部分组成:  一个是操作系统用来管理进程的内核对象。内核对象也是系统用来存放关于进程的统计信息的地方  另一个是地址空间,它包含所有的可执行模块或...
  • 本文在ubuntu16.04下实现了python向c++发送数据的socket通信,同时在两个进程中分别开启两个线程,主线程负责处理数据,子线程负责socket通信
  • Windows和GNU / Linux的轻松进程通信! 欢迎使用ninjaipc:waving_hand:适用于Windows和GNU / Linux的简单IPC! ninjahandle ipc = ninjaipc :: create_server(“ ninjaipc”); ninjaipc :: listen(ipc,[ipc]...
  • 进程同步的方法 1、互斥量(Mutex):为协调共同对一个共享资源的单独访问而设计的。 2、信号量(Semaphore):现和纠正。 3、事件(Event): 线程间同步的方法: 1:临界区 2:锁 3:信号量 4:事件 ...
  • Windows进程通信-事件

    2014-08-06 10:34:06
    danny_share博客Windows进程通信之事件配套源码, 分为三个 EventMain和EventSubA和EventSubB三个工程实现使用事件通信, 1.不要F5直接运行 2.编译生成debug目录或者release目录以后,如果要实验第二部分生命周期的...
  • C++进程通信源码.zip

    2022-04-03 22:52:57
    C++进程通信源码.zip
  • C++ 进程通信详解

    千次阅读 2021-06-22 15:03:54
    一,C++ 常用进程通信 管道(Pipe):管道可用于具有亲缘关系进程间的通信,允许一个进程和另一个与它有共同祖先的进程之间进行通信。 命名管道(namedpipe):命名管道克服了管道没有名字的限制,因此,除具有管道...
  • C++进程通信的4中方式

    千次阅读 2016-12-30 16:22:53
    C++进程通信进程间通讯的四种方式:剪贴板、匿名管道、命名管道和邮槽剪切板
  • 通过 DDEML 开发 Windows 进程通信 的 C/C++ 示例程序代码
  • Linux下C++进程通信的八种方法

    千次阅读 2018-07-12 14:23:56
    Linux下进程通信的八种方法:管道(pipe),命名管道(FIFO),内存映射(mapped memeory),消息队列(message queue),共享内存(shared memory),信号量(semaphore),信号(signal),套接字(Socket) (1) 管道(pipe):...
  • 这是一个多进程通信的程序,有一个主进程和各种类型的子进程进行通信。
  • C++使用共享内存 进程通信

    热门讨论 2013-05-02 20:14:44
    使用C++和共享内存实现在Server和Client之间共享数据
  • C++进程通信之剪贴板

    2016-12-16 15:17:47
    采用剪贴板的方式完成进程间的通信
  • Qt使用QLocalServer和QLocalSocket进行进程间通讯的实例,与QTcpSocket和QUdpSocket不同的是,QLocalServer和QLocalSocket使用pipe管道通讯,可以方便的建立后台本地服务器响应其他进程
  • C++进程通信之消息

    千次阅读 2016-12-19 15:49:21
    使用自定义消息来实现进程之间的通信
  • C# C++ 使用命名管道进行进程通信

    千次阅读 2019-01-06 15:01:13
    实现的功能:C#和C++的应用程序运行时,这两个进程间可以进行进程通信,互相发送和接收消息。 之前看了很多网上的代码写进程通信,大多数都是讲C#——C#或C++——C++这种相同类型的应用程序间的通信,很少有C#-&...
  • Windows进程通信之共享内存通信(C++)

    千次阅读 2019-05-08 17:44:11
    在我的理解,共享内存通信指的是,一个进程开辟一块内存,并且设定内存的读取方式,并且存放数据,然后另一个进程通过一个特定的key值来访问,并且读取里面的值。 接下来是我做的一个简单的客户端和服务...
  • 主要是对dbus进行c++封装成了一个dbus类,对外保留发送和接收的接口,方便使用;另外实现多进程dbus的双向通信测试,详细说明见博客的编译(移植)以及双向通信使用例程>>

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 96,088
精华内容 38,435
关键字:

c++ 进程通信

c++ 订阅