『Linux』进程间通信

最新推荐文章于 2025-07-11 21:12:42 发布
最新推荐文章于 2025-07-11 21:12:42 发布
阅读量665 收藏 1
点赞数 3
CC 4.0 BY-SA版权
分类专栏： 『Linux』 文章标签： Linux 进程间通信 管道 共享内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sss_0916/article/details/89285524

前面，学习进程的时候，我们都直到，进程具有独立性，也就是说，进程之间是相互隔离的，各自有自己的虚拟地址空间，各个进程只能访问自己虚拟地址空间内的内容，无法访问其他进程的虚拟地址空间。但是有时候需要多个进程相互协同完成任务，这时候进程之间就需要相互了解，所以就有了进程间通信，来为各个进程完成通信。

进程间通信目的

数据传输：一个进程将它的数据发送给另一个进程。
资源共享：多个进程之间共享同样的资源。
事件通知：一个进程需要向另一个进程或一组进程发送消息，通知它们发生了某种事件(如子进程终止要通知父进程)。
进程控制：有些进程希望完全控制另一个进程的执行(如Debug过程)，此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时直到它的状态改变。

进程间通信的分类

管道：

  • 匿名管道。
  • 命名管道。

System V IPC：

  • System V 消息队列。
  • System V 共享内存。
  • System V 信号量。

POSIX IPC：

  • 消息队列。
  • 共享内存。
  • 信号量。
  • 互斥量。
  • 条件变量。
  • 读写锁。

管道

什么是管道?

  • 管道是Unix中最古老的进程间通信方式。
  • 我们把从一个进程连接到另一个进程的一个数据流称为一个管道。

匿名管道

接口介绍：

功能：用于具有亲缘关系的进程间通信（父进程和子进程、同一个父进程的子进程之间等）。
int pipe(int pipefd[2]);		
参数：
    pipefd[0]：从管道读数据。
    pipefd[1]：从管道写数据。
返回值：表示是否创建成功，成功返回0，失败返回-1。

管道的读写特性：

  • 若管道中没有数据：
    O_NONBLOCK disable：read调用阻塞，直到读到数据返回。
    O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。

  • 若管道中数据满了(缓冲区满了)：
    O_NONBLOCK disable：write调用阻塞，直到有数据被读取，管道中有空闲位置，写入数据后返回。
    O_NONBLOCK enable：write调用返回-1，errno值为EAGAIN。

  • 若管道所有的读端都被关闭，则write会触发异常 – SIGPIPE – 导致进程退出(通知没人读了)。

  • 若管道所有的写端都被关闭，则read读完管道中的数据后返回0(通知没人写了)。

  • 当要写入的数据量不大于PIPE_BUF时，Linux将保证写入操作的原子性；当要写入的数据量大于PIPE_BUF时，Linux将不再保证写入操作的原子性。

管道特点

  • 只能用于具有亲缘关系的进程间进行通信；通常是一个进程创建管道，拿到管道描述符，然后调用fork，此时父子进程就都可以使用该管道。
    在这里插入图片描述
  • 管道自带同步与互斥特性，当读写大小小于PIPE_BUF时，保证操作的原子性。管道默认大小65536（64K）。可以使用命令ulimit -a查看。
    在这里插入图片描述
  • 管道生命周期随进程，进程退出，管道释放。
  • 管道是一个半双工通信(可选择方向的单向通信)，需要双方通信时，需要建立其两个管道。
    在这里插入图片描述

代码演示：

#include <iostream>
#include <unistd.h>
#include <stdio.h>
#include <string>
#include <stdlib.h>

int main(){
	// 保存匿名管道描述符组
	// pipefd[0]：读端
	// pipefd[1]：写端
	int pipefd[2];

	// 创建匿名管道
	int ret = pipe(pipefd);
	if(ret < 0){
		// 管道创建失败
		perror("pipe error");
		return -1;
	}

	// 创建子进程
	pid_t pid = fork();
	if(pid < 0){
		// 进程创建失败
		perror("fork error");
		return -1;
	}
	else if(pid == 0){
		// 子进程，写，关闭读端
		close(pipefd[0]);

		// 保存要写入管道的数据
		std::string write_buf;

		while(1){
			std::cout << "child: ";
			// 从标准输入写入数据
			getline(std::cin, write_buf);

			// 将数据写入管道
			write(pipefd[1], write_buf.c_str(), write_buf.size());
			usleep(1);
		}

		exit(0);
	}
	else{
		// 父进程，读，关闭写端
		close(pipefd[1]);

		// 保存读到的数据
		std::string read_buf;
		read_buf.resize(1024);

		while(1){
			// 从管道读数据
			read(pipefd[0], &read_buf[0], read_buf.size());
			std::cout << "parent: " << read_buf << std::endl;
		}
	}

	return 0;
}

编译运行，效果如下：
在这里插入图片描述

匿名管道实现命令连接：

#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(){
	// 保存管道描述符
	int pipefd[2];

	// 创建匿名管道
	int ret = pipe(pipefd);
	if(ret < 0){
		// 管道创建失败
		perror("pipe error");
		return -1;
	}

	// 创建子进程
	pid_t pid1 = fork();
	if(pid1 < 0){
		// 进程创建失败
		perror("pipe error");
		return -1;
	}
	else if(pid1 == 0){
		// 子进程，写，关闭读端
		close(pipefd[0]);

		// 将标准输出重定向到匿名管道的写端
		dup2(pipefd[1], 1);

		// 程序替换
		execlp("ps", "ps", "-ef", NULL);
	}

	// 创建子进程
	pid_t pid2 = fork();
	if(pid2 < 0){
		// 进程创建失败
		perror("fork error");
		return -1;
	}
	else if(pid2 == 0){
		// 子进程，读，关闭写端
		close(pipefd[1]);

		// 重定向，将标准输入重定向到管道读端
		dup2(pipefd[0], 0);

		// 程序替换
		execlp("grep", "grep", "ssh", NULL);
	}

	close(pipefd[0]);
	close(pipefd[1]);

	// 阻塞等待子进程退出
	waitpid(pid1, NULL, 0);
	waitpid(pid2, NULL, 0);

	return 0;
}

编译运行程序，效果如下：
在这里插入图片描述

命名管道

  • 匿名管道的应用有一个限制，只能是具有亲缘关系的进程间通信。
  • 想要在不想关的进程间交换数据，可以通过FIFO文件来完成，这就是命名管道。
  • 命名管道是一种特殊类型的文件。

命名管道的创建（两种方法）：

  • Linux下命令创建。
    在这里插入图片描述
  • 接口创建。
    在这里插入图片描述

命名管道的打开特性：
如果当前打开操作是为读而打开FIFO时：

  • O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO。
  • O_NONBLOCK enable：立刻返回成功。

如果当前打开操作是为写而打开FIFO时：

  • O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO。
  • O_NONBLOCK enable：立刻返回失败，错误码为ENXIO。

使用命名管道实现server向client发送消息：
服务端：

#include <iostream>
#include <sys/stat.h>
#include <stdio.h>
#include <string>
#include <fcntl.h>
#include <unistd.h>

int main(){
	// 设置mask
	umask(0);

	// 文件实际权限为：0644 & (~mask)
	int ret = mkfifo("my_pipe.fifo", 0644);
	if(ret < 0){
		// 管道文件创建失败
		perror("mkfifo error");
		return -1;
	}

	// 读方式打开管道
	int fd = open("my_pipe.fifo", O_RDONLY);
	if(fd < 0){
		// 文件打开失败
		perror("open error");
		return -1;
	}

	// 接收服务端发来的消息
	std::string buf;
	buf.resize(1024);

	while(1){
		std::cout << "Please wait...\n";
		// 读管道
		ssize_t ret = read(fd, &buf[0], buf.size());
		if(ret > 0){
			// 打印读取到的管道中的内容
			std::cout << "client# " << buf << std::endl;
		}
		else if(ret == 0){
			// 管道写端关闭
			std::cout << "client quit!\n";
			return 0;
		}
		else{
			// 读取失败
			perror("read error");
			return -1;
		}
	}

	// 关闭描述符
	close(fd);

	return 0;
}

客户端：

#include <iostream>
#include <fcntl.h>
#include <string>
#include <unistd.h>
#include <stdio.h>

int main(){
	// 打开管道文件
	int fd = open("my_pipe.fifo", O_WRONLY);
	if(fd < 0){
		// 文件打开失败
		perror("open error");
		return -1;
	}

	// 保存要写入管道的数据
	std::string buf;
	while(1){
		std::cout << "Please input: ";
		fflush(stdout);

		// 写入buf
		getline(std::cin, buf);

		// 写入管道文件
		write(fd, &buf[0], buf.size());
	}

	close(fd);

	return 0;
}

最后，我们写一个makefile：
在这里插入图片描述
编译程序：
在这里插入图片描述
先运行服务端，再另开一个终端运行客户端，效果如下：
在这里插入图片描述

匿名管道和命名管道的区别：

  • 匿名管道由pipe函数创建并打开。
  • 命名管道由mkfifo函数创建，打开用open。
  • 匿名管道只能用于具有亲缘关系的进程之间通信，命名管道则没有这个限制。

共享内存

内存共享是最快的进程间通信方式，因为相较于其他进程间通信方式，少了多次的拷贝，如：管道在写入时需将数据从用户态拷贝到内核态，用的时候，需要从内核态拷贝到用户态，共享内存直接将一块内存映射到用户空间，用户可以直接通过地址对内存进行操作，并反馈到其他进程，少了数据拷贝的操作。
在这里插入图片描述

接口介绍：

int shmget(key_t key, size_t size, int shmflg);
功能：创建共享内存。
参数：
    key：共享内存在操作系统中的标识符不建议使用ftok()来生成key，建议随便给一个。
    size：共享内存大小。
    shmflg：打开方式/创建权限。
    		IPC_CREAT	不存在则创建。
    		IPC_EXCL	与IPC_CREAT同用，存在报错，不存在则创建。
    		mode_flags。
返回值：共享内存在程序内的操作句柄shmid，失败返回-1。

void* shmat(int shmid, const void* shmaddr, int shmflg);
功能：将共享内存映射到虚拟地址空间。
参数：
    shmid：创建共享内存返回的操作句柄。
    shmaddr：用于指定映射在虚拟地址空间的首地址，通常置NULL(因为我们是菜鸡)。
    shmflg：一般设置为0，可读可写。
返回值：映射首地址(通过这个地址对共享内存进行操作)，失败返回(void*)-1。

int shmdt(const void* shmaddr);
功能：解除映射关系。
参数：
	shmaddr：映射首地址。
返回值：成功返回0，失败返回-1。
注意：将共享内存端与当前进程脱离不等于删除共享内存段。

int shmctl(int shmid, int cmd, struct shmid_ds* buf);
功能：删除共享内存。
参数：
    shmid：操作句柄。
    cmd：
    	IPC_RMID：删除共享内存。
    	IPC_STAT：把shmid_ds结构中的数据设置为共享内存的当前关联值。
    	IPC_SET：在进程有足够权限的前提下，把共享内存的当前关联值设置为
    			 shmid_ds数据结构中给出的值。
    buf：设置或者获取共享内存信息，用不着则置NULL。
返回值：成功返回0，失败返回-1。
注意：共享内存并不是立即删除，只是拒绝后序映射链接，
	 当内存映射链接数为0时，则删除。共享内存没有同步与互斥，注意sleep。

共享内存数据结构：

struct shmid_ds {
	struct ipc_perm shm_perm; /* operation perms */
	int shm_segsz; /* size of segment (bytes) */
	__kernel_time_t shm_atime; /* last attach time */
	__kernel_time_t shm_dtime; /* last detach time */
	__kernel_time_t shm_ctime; /* last change time */
	__kernel_ipc_pid_t shm_cpid; /* pid of creator */
	__kernel_ipc_pid_t shm_lpid; /* pid of last operator */
	unsigned short shm_nattch; /* no. of current attaches */
	unsigned short shm_unused; /* compatibility */
	void *shm_unused2; /* ditto - used by DIPC */
	void *shm_unused3; /* unused */
};

代码演示如下：

// share_mem_server.cc
#include <iostream>
#include <sys/shm.h>
#include <stdio.h>
#include <unistd.h>

// 随意给一个数字就好
#define KEY 123
// 共享内存大小
#define SHM_SIZE 4096

int main(){
	// 创建共享内存
	int shmid = shmget(KEY, SHM_SIZE, IPC_CREAT | 0666);
	if(shmid < 0){
		// 创建共享内存失败
		perror("shmget error");

		return -1;
	}

	// 共享内存映射到虚拟地址空间
	char* shm_start = (char*)shmat(shmid, NULL, 0);
	if(shm_start == (void*)-1){
		// 映射事变
		perror("shmat error");

		return -1;
	}

	while(1){
		// 打印共享内存中的内容
		std::cout << "# " << shm_start << std::endl;
		sleep(1);
	}

	// 解除映射关系
	shmdt(shm_start);

	// 删除共享内存
	shmctl(shmid, IPC_RMID, NULL);

	return 0;
}

// share_mem_client.cc
#include <iostream>
#include <sys/shm.h>
#include <stdio.h>
#include <unistd.h>

// 随意给一个数字就好
#define KEY 123
// 共享内存大小
#define SHM_SIZE 4096

int main(){
	// 创建共享内存
	int shmid = shmget(KEY, SHM_SIZE, IPC_CREAT | 0666);
	if(shmid < 0){
		// 创建失败
		perror("shmget error");

		return -1;
	}

	// 共享内存映射到虚拟地址空间
	char* shm_start = (char*)shmat(shmid, NULL, 0);
	if(shm_start == (void*)-1){
		// 映射失败
		perror("shm_start error");

		return -1;
	}

	int i = 1;
	while(1){
		sprintf(shm_start, "[马上就要有师弟师妹了，开心~~+%d]", i++);
		sleep(1);
	}

	// 解除映射关系
	shmdt(shm_start);

	// 删除共享内存
	shmctl(shmid, KEY, NULL);

	return 0;
}

我们再写一个makefile，编译如下：
在这里插入图片描述
在这里插入图片描述
在一个终端运行client，在另一个终端运行server：
在这里插入图片描述
在这里插入图片描述

查看共享内存：

[sss@aliyun ~]$ ipcs -m

在这里插入图片描述
删除共享内存：

[sss@aliyun ~]$ ipcrm -m shmid

注意：共享内存没有进行同步与互斥。

Linux-进程间通信
AI_ELF的博客
08-23 7353
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
Linux——进程间通信
weixin_51526796的博客
03-28 1119
父子进程间如何实现信息沟通，之前了解到的有：父进程创建子进程，子进程是从父进程那里copy某些数据过来。只是子进程子进程退出的时候，调用exit（0），然后父进程调用wait（status）等待子进程退出获取子进程退出状态信息，把退出码返回给父进程，可通过宏来读取退出码。还有的就是，exec族函数，如让A进程去启用B进程，A后面的代码就不跑了，去跑的。但综上都不是真正意义上的通信，真正的通信，通过一进程写入信息，二进程可以读取，二进程写入信息，一进程可以读取。
Linux： 进程间通信
2301_79927432的博客
03-29 2271
在我们学习进程的时候，我们知道正是因为程序地址空间的存在，所以进程之间具有独立性，他们互不影响，但是在我们的实际应用中，进程之间总会有需要通信（交流获取对方数据）。
Linux_3：进程间通信
最新发布
weixin_51368966的博客
07-11 965
1.什么是IPC？2.进程间通信常用的几种方式1，管道通信：有名管道，无名管道2，信号- 系统开销小3，消息队列-内核的链表4，信号量-计数器5，共享内存6，内存映射7，套接字。
Linux —— 进程间通信
M的博客
07-23 6487
进程间通信方式的介绍：管道通信、system V通信......
＜Linux＞ 进程间通信
prodigy623的博客
09-15 2750
进程间通信，匿名管道、命名管道、共享内存、消息队列、信号量
Linux之进程间通信
cls的博客
03-22 5028
共享内存在内核中申请的基本单位是页，这个页叫做内存页，这个内存页叫做4KB。如果我申请4097个字节，内核会向上取整，给你4096byte*2（多要了一个就得多申请一页，因为没有4097）。但是我们实际看到的并不是4096*2，而是4097，这又是怎么回事呢？如果我向OS要了10个字节，OS只给了9个，我就认为是错的，因为很容易发生越界，OS就有问题。
Linux进程间通信方式之socket使用实例
09-15
### Linux进程间通信方式之socket使用实例详解 #### 一、引言 在现代操作系统中，进程间的通信（IPC）是实现多进程协同工作的重要手段之一。Linux提供了多种进程间通信的方法，包括信号量、消息队列、共享内存以及...
UNIX Linux实验教程 4实验四Linux进程间通信.doc
09-26
UNIX/Linux 进程间通信实验教程 UNIX/Linux 操作系统提供了一组系统调用作为用户使用其进程间通信机制的接口。进程间通信是指在多任务计算机系统中，每个进程都具有自己独立的全局变量和局部变量，子进程几乎完全...
浅谈Linux进程间通信方式及优缺点
01-11
有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信。 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制...
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
Linux进程间通信--使用信号
09-15
Linux进程间通信是一种让不同进程之间交换信息或协调工作的方式，而在Linux系统中，信号（Signal）是一种简单但重要的通信机制。本文将深入探讨如何利用信号进行进程间通信。 首先，信号是操作系统用来通知进程发生...
Linux进程间通信(Linux IPC)
Peerless__的博客
06-04 7136
在Linux下由很多种进程间通信的方式，在下面主要介绍七种，分别是：匿名管道(PIPE)、命名管道(FIFO)、信号、共享内存映射、共享内存、消息队列、信号量、UNIX域套接字。
Linux系统进程间通信
嵌入式技术与人工智能
03-03 959
Linux系统进程间通信一、Linux进程间通信概述二、信号 Linux系统进程间通信概述 一、Linux进程间通信概述 Linux系统进程通信手段是基于UNIX平台的进程通信的。UNIX的进程通信机制主要包括两种：（1）针对单个计算机的system V IPC与（2）基于套接口（socket）的进程通信机制，因此，Linux系统包含这两种进程通信机制，除此之外，Liunx系统还有POSIX进程间通信方式。 Linux系统的进程间通信主要包括以下几种手段： （1）管道（pipe）与有名管道（name
Linux系统之进程间通信
指尖动听知识库
09-11 828
在Linux系统中，进程间通信（Inter-Process Communication，IPC）是不同进程之间进行数据交换和同步的一种机制。
linux——进程间的通信
qq_47944751的博客
10-15 344
进程间通信
Linux系统-进程间通信
~
10-11 3658
本章主要讲解学习Linux中本系统下的进程间通信概念：进程间通信简称IPC（Inter process communication），进程间通信就是在不同进程之间传播或交换信息进程间通信目的：数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）
＜ Linux ＞ 进程间通信
bit_zyx的博客
02-25 1008
目录 1、进程间通信介绍 进程间通信的概念 进程间通信的本质 进程间通信的分类 2、管道 2.1、什么是管道 2.2、匿名管道 匿名管道的原理 pipe函数 匿名管道使用步骤 2.3、管道的读写规则 2.4、管道的特点 2.5、命名管道 命名管道的原理
Linux进程间通信详解
"该资源为一份关于Linux进程间通信的PDF文档，由孙天泽于2006.3年撰写，主要介绍了Linux系统中的进程通信机制，适用于嵌入式Linux应用程序开发的学习与实践。文档内容包括Linux进程、内核开发、驱动程序开发以及应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值