Linux操作系统应用程序设计——五种进程间的通信方式

已于 2022-08-15 16:27:03 修改
阅读量1.5k 收藏 13
点赞数 2
分类专栏： 网络编程 文章标签： linux c语言
于 2022-08-07 16:06:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52109967/article/details/126209679
版权

文章目录

前言

1、通常来说进程间的通信方式共有六种：
（1）管道通信 ——无名管道 (pipe)、有名管道 (fifo)
（2）信号通信 (sinal)
（3）信号量 (Semaphore)
（4）共享内存 (SharedMemory)
（5）消息队列 (MessageQueue)
（6）套接字 (Socket)
但是本文只介绍前五种，你肯定疑惑了，第六种为什么不说？
那原因也很简单，我觉得文章太长了!

一、管道通信

1、无名管道

1、无名管道的特点：
（1）只能用于具有亲缘关系的进程之间的通信
（2）是一个单工的通信模式，具有固定的读端和写端
（3）管道也可以看成一种特殊文件，对他的读写可以使用read()，write()函数
2、原理示意图：
在这里插入图片描述
3、pipe函数
功能：创建无名管道

头文件：
#include<unistd.h>
函数原型：
int pipe(int fd[]);
参数：
fd[]:包含两个元素的整型数组，存放读端和写端的文件描述符
例子：
#include <stdio.h>
#include <unistd.h>
int main()
{
	int fd[2];		
	pipe(fd);		//传出两个文件描述符  fd[0]    fd[1]
	int pid = fork();
	if(pid == 0)//子进程
	{	
		close(fd[0]);	//子进程关闭读端
		write(fd[1], "hello", sizeof("hello"));
	}
	else if(pid > 0)//父进程
	{
		char buf[100] = { 0 };
		close(fd[1]);//父进程关闭写端
		wait(NULL);//等待子进程结束
		read(fd[0], buf, sizeof(buf));//读出数据	
		printf("read is %s\n", buf);//打印
	}
}

2、有名管道

1、有名管道的特点：
（1）可以使两个不相关的进程实现彼此通讯
（2）该管道可以通过路径名指出，在文件系统中可见
（3）严格遵守先进先出的规则，在开始处读数据，末尾处写数据
2、原理示意图：
在这里插入图片描述
3、mkfifo函数
功能：创建有名管道

头文件：
#include<sys/types.h>
#include<sys/state.h>
函数原型：
int mkfifo(const char *filename,mode_t mode);
参数：
filename：要创建的管道名
mode：管道的访问权限
例子：
//读端
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
int main()
{
	mkfifo("myfifo", 0666);		
	int fd = open("myfifo", O_RDWR);
	if(fd > 0)
	{
		char buf[100] = { 0 };
		read(fd, buf, sizeof(buf));
		printf("read is %s\n", buf);
		close(fd);
	}
}
//写端
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
int main()
{
	int fd = open("myfifo", O_RDWR);
	if(fd > 0)
	{
		write(fd, "hello", sizeof("hello"));
		close(fd);
	}
}

二、信号通信

1、信号是进程间通信机制中唯一的异步通讯机制
2、进程可以通过三种方式来响应信号
（1）忽略信号：对信号不做如何处理
（2）捕捉信号：定义信号处理函数，信号发生时，执行相应的处理函数
（3）执行默认操作：常见的信号如下
· SIGHUP：从终端上发出的结束信号。
· SIGINT：来自键盘的中断信号，即Ctrl+c。
· SIGKILL：该信号结束接收信号的进程。
· SIGCHLD：标识子进程停止或结束的信号。
· SIGSTOP：来自键盘Ctrl+z，或调试程序的停止执行信号。
· SIGQUIT：来自键盘的退出信号，即Ctrl+\。
· SIGALARM：进程的定时器到期，发送该信号。
3、kill函数
功能：发送信号给进程

头文件：
#include<signal.h>
#include<sys/types.h>
函数原型：
int kill(pid_t pid,int sig);
参数：
pid：发送信号给进程号为pid的进程
sig：信号类型
例子：
#include <signal.h>
int main()
{
	kill(11111, SIGINT);
}

4、signal函数
功能：定义一个函数，当产生某个信号时，自动执行此函数

头文件：
#include<signal.h>
函数原型：
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum,sighandler_t handler);
参数：
signum：指定信号代码
handler：SIG_IGN 忽略该信号
		SIG_DFL 采用系统默认方式处理信号
		自定义的信号处理函数
例子：
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
void *fun(int n)		//n 当产生某个信号时，信号值
{
	printf("recv a signal CTRL+C %d\n", n);
	exit(0);
}
int main()
{
	signal(SIGINT, fun);	
	while(1);		//不让程序结束	
}

5、alarm函数
功能：在进程中设定一个定时器，当定时器时间到了，发送一个SIGALARM信号给进程

头文件：
#include<unistd.h>
函数原型：
unsigned int alarm(unsigned int seconds);
参数：
seconds：指定秒数
例子：
//发送信号
#include <stdio.h>
int main()
{
	alarm(2);
	while(1)
	{
		printf("hello world\n");
		sleep(1);
	}
}
//接收信号
#include <stdio.h>
#include <signal.h>
void fun(int n)
{
	printf("recv a signal SIGALRM\n");
}
int main()
{
	alarm(1);	//1秒钟之后产生SIGALRM信号
	signal(SIGALARM, fun);	//捕获SIGALRM信号，执行fun
	while(1);	//不让程序暂停
}

三、信号量

那个，这个暂时先放一放。

四、共享内存

1、共享内存是一种最为高效的进程间通信方式：因为进程可以直接读写内存，不需要任何数据的复制
2、原理图：
在这里插入图片描述
3、shmget函数
功能：创建共享内存

头文件：
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
函数原型：
int shmget(key_t key,int size,int shmflg);
参数：
key：共享内存的键值
size：共享内存区的大小
shmflg：共享内存的权限，可以使用八进制表示法
返回值：
共享内存的标识符
例子：
#include <sys/shm.h>
#include <stdio.h>
int main()
{
	int shmid = shmget(55555, 10 * sizeof(int), 0666 | IPC_CREAT);//IPC_CREAT不存在就新建
	printf("shmid is %d\n", shmid);
}

4、shmat函数
功能：映射共享内存

头文件：
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
函数原型：
char *shmat(int shmid,const void *shmaddr,int shmflg);
参数：
shmid：要映射的共享内存区标识符
shmaddr：将共享内存映射到指定地址（若为0，表示系统自动分配地址，并把该段共享内存映射到调用进程的地址空间）
shmflg：共享内存的权限，可以使用八进制表示法
返回值：
被映射的段地址
例子：
int *p = shmat(shmid, NULL, 0);

5、shmdt函数
功能：撤销映射

头文件：
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
函数原型：
int shmdt(const void *shmaddr);
参数：
shmaddr：被映射的共享内存段地址
例子：
#include <sys/shm.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int shmid = shmget(IPC_PRIVATE, 10 * sizeof(int), 0644);
	printf("shmid %d\n", shmid);
	int i;
	int pid = fork();		//创建子进程
	if(pid == 0)			//子进程在运行
	{
		//写共享内存
		int *p = shmat(shmid, NULL, 0);	//映射
		for(i = 0; i < 10; i++)
		{
			p[i] = i;		//写入共享内存
		}	
		shmdt(p);			//解除映射
		exit(0);			//子进程结束
	}
	else if(pid > 0)
	{
		//读共享内存
		wait(NULL);			//等子进程结束
		int *p = shmat(shmid, NULL, 0);	//映射
		for(i = 0; i < 10; i++)
		{
			printf("%d\n", p[i]);	//读出
		}	
		shmdt(p);			//解除映射
	}
}

五、消息队列

1、消息队列就是一些消息的列表，可以实现消息的随机查询，这些消息存在于内核中，有队列ID来标识。
2、msgget函数
功能：

头文件：
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
函数原型：
int msgget(key_t key,int msgflg);
参数：
key：消息队列的键值
msgflg：权限标志位
返回值：
消息队列ID

3、msgsnd函数
功能：

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
函数原型：
int msgsnd(int msqid，const void *msgp，size_t msgsz,int msgflg);
参数：
msqid：消息队列的队列ID
msgp：指向消息结构的指针
struct msgbuf
{
	long mtype；//消息类型
	char mtext[100];//消息正文
}
msgsz：消息正文的字节数
msgflg：IPC_NOWAIT 消息无法发送函数立即返回
		0 调用阻塞直到发送成功

4、msgrcv函数
功能：

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
函数原型：
int msgrcv(int msqid，const void *msgp，size_t msgsz,long int msgtyp，int msgflg);
参数：
msqid：消息队列的队列ID
msgp：消息缓冲区
struct msgbuf
{
	long mtype；//消息类型
	char mtext[100];//消息正文
}
msgsz：消息正文的字节数
msgtyp：0 接收消息队列第一个消息
		大于0 接收消息队列第一个类型为msgtyp的消息
		小于0 接收消息队列中第一个类型值不小于msgtyp绝对值且类型值又最小的消息
msgflg：IPC_NOWAIT 若消息队列没有对应类型的消息，函数立即返回
		0 调用阻塞直到接收成功

5、msgctl函数
功能：删除队列消息

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
函数原型：
int msgctl(int msqid，int cmd，struct msqid_ds *buf);
参数：
msqid：消息队列的队列ID
cmd：IPC_RMID 从系统内核中删除消息队列
buf：通常为NULL

6、例子

//发送消息
#include <sys/msg.h>
#include <stdio.h>
#include <string.h>
struct msgbuf
{
	long mtype;
	char mtext[100];
};

int main(int argc, char *argv[])
{
	if(argc < 3)
	{
		printf("param error, like this: ./send 1 hello\n");
		return -1;
	}
	struct msgbuf a;
	a.mtype = atoi(argv[1]);//接收消息类型
	strcpy(a.mtext, argv[2]);//接收消息正文
	int msgid = msgget(11111, 0666 | IPC_CREAT);//创建消息队列
	msgsnd(msgid, &a, sizeof(a) - sizeof(long), 0);//发送消息
}
//接收消息 
#include <sys/msg.h>
#include <sys/ipc.h>
#include <stdio.h>
struct msgbuf
{
	long mtype;
	char mtext[100];
};

int main(int argc, char *argv[])
{
	struct msgbuf b;//定义结构体变量
	if(argc < 2)
	{
		printf("param error, like this: ./recv 1\n");
	}
	int msgid = msgget(11111, 0666 | IPC_CREAT);//创建消息队列
	msgrcv(msgid, &b, sizeof(b) - sizeof(long), atoi(argv[1]), 0);//接收消息正文
	printf("msg type is %lu, buf is %s\n", b.mtype, b.mtext);//打印
}

总结

总结不动了！

Conspicuous.
关注
专栏目录
操作系统实验——进程创建与进程间通信
06-05
总之，操作系统实验中的进程创建与进程间通信是一个很好的实践平台，它能帮助你理解操作系统的底层机制，提升系统编程能力。通过实际操作，你将能够更深入地了解操作系统如何管理和协调多个并发执行的进程，以及如何...
Linux 进程间通信
人生一世 草木一秋
08-12 2699
Linux进程通信继承了传统的UNIX进程间通信方式，包括无名管道、有名管道以及信号；还有System V进程间通信（IPC），包括System V消息队列、System V信号量以及System V共享内存；套接字。
linux进程间的7种通信方式全解析及代码示例
q472599451的专栏
09-04 2712
管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。
＜Linux＞ 进程间通信
最新发布
prodigy623的博客
09-15 1430
进程间通信，匿名管道、命名管道、共享内存、消息队列、信号量
Linux进程间通信的五种方式
qq_38813765的博客
09-20 2927
一、管道一、管道二、 信号三、共享内存四、消息队列五、信号量。
1.Linux——进程间的五种通信方式（管道、消息队列、共享存储、信号、信号量）
weixin_48326567的博客
04-02 2104
进程间通信（IPC，InterProcess Communication）是指在不同的进程之间传播或交换信息。
Linux进程间通信(Linux IPC)
Peerless__的博客
06-04 6844
在Linux下由很多种进程间通信的方式，在下面主要介绍七种，分别是：匿名管道(PIPE)、命名管道(FIFO)、信号、共享内存映射、共享内存、消息队列、信号量、UNIX域套接字。
进程间软中断通信（signal函数和kill函数）
06-04 4612
在Linux中signal函数是比较复杂的一个,其定义原型如下: void (*signal(int signo,void (*func)(int))) (int) 这个函数中,最外层的函数体 void (* XXX )(int)表明是一个指针,指向一个函数XXX的指针,XXX所代表的函数需要一个int型的参数,返回void signal(int signo, void(*func)(int))是
操作系统课程设计报告(进程控制与进程通信)
04-07
操作系统课程设计报告主要探讨了进程控制与进程通信的概念，并通过一个具体的实例——计算10000个浮点数的和与平均值——来展示这些概念的实际应用。在这个设计中，父进程首先生成一系列随机浮点数，然后创建四个子...
高级进程间通信问题——快速排序问题1
08-03
【高级进程间通信问题——快速排序问题1】的实验是一个基于操作系统原理的编程挑战，旨在实现一个多线程或多进程的快速排序算法。这个实验在Ubuntu 18.04.5 LTS环境下进行，采用C/C++编程语言，并且允许使用C++11的...
操作系统课程设计说明书基于Linux的进程之间通信.doc
09-22
本课程设计旨在通过实现基于Linux操作系统的进程间通信机制，让学生深入理解操作系统中的并发控制与同步策略。其中，重点是通过信号量机制解决著名的哲学家进餐问题，以防止死锁的发生。以下是设计的具体内容和步骤...
操作系统课设-进程互斥与调度
11-21
在这个操作系统课程设计中，学生们被要求深入理解并发执行的原理，并通过编程实践来解决进程间的资源竞争问题，同时掌握两种关键的调度算法——时间片轮转和优先权调度。 首先，进程互斥是确保同一时刻只有一个进程...
linux向指定窗口发送消息,PostMessage向窗口发送Alt组合键
weixin_33448981的博客
05-13 777
关于向Windows窗口发送Alt组合键的问题,这个真是经典问题啊,在网上找了一下,问的人N多,方法差不多,但就是没有很好解决问题。之前找到一个能正确发送的code:(Alt+A)PostMessage(hWnd,WM_SYSKEYDOWN,VK_MENU,0);PostMessage(hWnd,WM_SYSKEYDOWN,0x41,0);Sleep(50);PostMessage(hWnd,WM...
Linux进程间通信
weixin_59371851的博客
08-26 1331
哈喽，小伙伴们大家好。我们都知道在完成一个任务时，往往是多个进程一起协调工作的，那么在工作的过程中，进程间必然需要产生交流，那么它们之间是如何交流的呢？本篇文章将给大家答疑解惑，详细讲解进程间通信。事不宜迟，快拿起小本本，和我一起开始吧。一、进程通信介绍共享内存是进程通信的最快方式，因为在读写共享内存的时候，并没有使用系统接口，直接就可以访问。共享内存通信优点：速度块，拷贝次数少。共享内存通信缺点：没有提供保护机制（互斥和同步）。...
操作系统笔记(4):通过信号signal进行进程间通信——kill()系统调用实现的软中断
Cake_C的博客
05-17 1126
kill的理解 看到这里的同学应该至少知道，在LinuxShell里面， 用kill命令可以指定一个进程PID然后杀掉吧 如图 先用ps -all获取所有可见进程列表，找到想要杀掉的进程PID（这里是一个叫做m的进程） 用kill命令即可杀掉。 但事实上，这里的kill尽管是在命令行里面敲出来的，其本质还就是一种进程间通信 从你的命令行(普通用户的)bash进程发送给指定PID的进程，然后触发接收进程的软中断，进程就暂停手下的工作，去执行默认的信息接收处理程序。 然后直接输入kill默认带有参数为-15，
Linux -- 进程间通信的五种方式
qq_61391875的博客
05-26 1872
IPC（InterProcess Communication）的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中Socket和Stream支持不同主机上的两个进程IPC。：管道是一种半双工的通信方式，用于具有亲缘关系的进程间通信。它通常用于父子进程或者兄弟进程之间。管道可以是匿名管道，也可以是命名管道。：消息队列是一种通过消息传递进行通信的方式。发送方将消息发送到队列中，接收方从队列中接收消息。消息队列可以实现进程间的异步通信。
linux进程间通信方法汇总
zeigongzi的专栏
12-31 587
Linux进程间通信的方法基本是从UNIX平台继承而来。Linux操作系统不但继承了system V IPC通信机制，还继承了基于套接字的进程间通信机制。前者的通信进程局限于单台计算机内；后者可以在不同主机上通信，即网络通信。 Linux进程间通信的方法： 1. 管道(pipe)：管道是一种半双工的通信方法，数据只能单向流动，而且只能在父子进程间使用。 2. 有名管道（named
Linux 7种 进程间通信方式
CSDN_DU666666的博客
06-23 835
通过文件实现进程间通信 必须人为保证先后顺序 A--->硬盘---> B（B不知道A什么时候把内容传到硬盘中）1.无名管道2.有名管道3.信号4.消息队列5.共享内存6.信号灯集原理：如果A和B进程想要通过无名管道通信，那就，A进程向管道的一端写数据，B进程可以从管道的另外一端读数据。在A进程和B进程进行数据传输的时候是的。无名管道是的通信方式。如果A进程一直向管道中写数据写满64K的时候A进程阻塞，直到B进程读一部分数据之后A才能继续写。
Linux进程通信的四种方式——共享内存、信号量、无名管道、消息队列｜实验、代码、分析、总结
SylvanDing's Blog
03-05 4287
本次实验基于Linux系统实现了进程的共享内存、管道和消息队列等三种IPC方式。其中，共享内存使各个进程共享一段物理内存空间，管道为父子进程间信息传递带来便捷，消息队列提供了消息类型选择机制。实验还通过信号量改进了共享内存，实现了进程对存储空间的互斥访问。通过实验，初步掌握了Linux系统的IPC操作，了解了他们各自的优缺点。
Linux程序设计：深入理解文件操作与系统调用
最后，管道文件虽然没有详细展开，但通常指的是内建于Unix-like系统（包括Linux）中的特殊文件类型，用于进程间通信（IPC）。通过管道，一个进程可以将数据传递给另一个进程，而不必将数据写入磁盘，提高了效率。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值