linux下进程通信

最新推荐文章于 2024-10-16 10:37:47 发布
最新推荐文章于 2024-10-16 10:37:47 发布
阅读量277 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Liunx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sun_student/article/details/89039585

1.基本介绍

    进程间通信的目的：数据传输、资源共享、进程控制

    如何通信的？

        1.因为进程独立性，因此通信需要双方拥有公共的媒介才能通信，而这个媒介由操作系统提供；

        2.因为通信场景不同，因此操作系统也提供多种不同的进程间通信方式；

2.进程间通信方式：

    1>管道：匿名管道/命名管道---半双工通信1

    

    管道原理：操纵系统在内核创建一块缓冲区，并且为用户提供管道的操作句柄（文件描述符），用户通过IO接口实现管道的操作；描述符共有两个一个用于读数据，一个用于写数据

    匿名管道：匿名管道是匿名的，其他进程在内核中无法找到这个管道，因此匿名管道实现进程间通信，只能用于具有亲缘关系的进程（子进程通过复制父进程的pcb--得到管道的操作句柄（两个文件描述符））

    管道读写特性：

        若管道中没有数据，那么如果read读取数据，则会阻塞，直到读到数据返回

        若管道中数据满了，那么如果继续write写入数据，则会阻塞，直到能够写入数据

        如果所有读端关闭了，这时候write写入数据则会触发异常----SIGPIPE（导致程序退出）

        如果所有写端都关闭了，这时候read读取数据，将数据读完后继续则会返回0

        管道自带同步与互斥

        同步：保证临界资源访问的时序可控性

        互斥：保证临界资源同一时间的唯一访问性

    管道符的实现：连接两个命令，将第一个命令的输出结果作为第二个命令的输入数据处理 ls | grep make

       主进程创建两个子进程，在两个中分别进行程序替换让两个子进程分别运行ls程序和grep程序

        ls程序是浏览目录，将结果写入到标准输出

        grep程序是标准输入读取数据（循环读取数据），进行过滤

        

        因为进程1，执行的ls程序将结果写入到了标准输出，而不是管道，并没有将数据交给其他进程因此需要对进程1，进行一个标准输出重定向，将ls的结果不是写入标准输出，而是写入到管道

        因为进程2，执行的gerp程序是从标准输入读取数据处理，而不是管道，因此无法获取前边命名的结果，因此需要对进程2，进行一个标准输入重定向，为了将本身从0指向的标准输入读取数据改为从管道读取段读取数据

        因为进程2不知道具体前边命令写入多少数据，因此只能循环读取，读取多少处理多少；

        问题：加入管道中数据已经读取完了，读不到数据则会导致read阻塞-进程2无法退出；因此需要将所有的管道写入段关闭掉，这时候读取不到数据但会0，认为没有数据了，就退出了；

    命名管道：具有名字的管道----体现在文件系统可见性

        创建命名管道会在文件系统中创建一个管道文件，本机上的所有进程都可以通过打开这个管道文件进而访问管道实现进程间通信

        创建命名管道的方式：1、命令行方式创建：mkfifo filename；2、从程序中创建 int mkfifo(cosnt char *fifoname, mode_t mode);

        命名管道可以实现同一主机上任意进程间通信

    open打开特性：

        若管道文件以只读打开，但是当前这个管道文件又没有被其它进程以写的方式打开，则阻塞，阻塞到其他进程以写的方式打开这个管道文件

        若管道文件以只写打开，但是当前这个管道文件又没有被其它进程以读的方式打开，则阻塞，阻塞到其他进程以读的方式打开这个管道文件

    命名管道读写特性同于匿名管道

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

        命名管道可以同一主机任意进程间通信，但是匿名管道只能用于具有亲缘关系的进程间通信，----因为命名管道有名字（有文件可见于文件系统之中）

    匿名管道实现代码：

/*匿名管道的使用*/
 
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
 
int main(){
     //int pipe(int pipefd[2]);
     //pipefd:用于接受管道的操作句柄（文件描述符）
     //返回值：成功：0  失败：-1
     int pipefd[2];
     int ret = pipe(pipefd);
     if(ret < 0){
         perror("pipe error");
         return -1;
     }
 
     int pid = fork();
     if(pid < 0){
         perror("fork error");
         exit(-1);
     }else if(pid == 0){
         close(pipefd[0]);
         //子进程写数据leihoua~~
         int len = 0;
         while(1){
             char *ptr  = "leihoua~~";
             printf("write len: %d\n", len);
             int ret = write(pipefd[1], ptr, strlen(ptr));
             len += ret;
             printf("write len: %d\n", len);
         }
     }else{
         close(pipefd[1]);
         //父进程读数据
         char buf[1024] = {0};
         int ret = read(pipefd[0], buf ,1023);
         printf("child read buf:[%d-%s]\n", ret, buf);
     }
     return 0;
 }

命名管道代码实现：

    读端：

/*************************************************************************
	> File Name: fifo_read.c
	> Author: ssh
	> Mail: sunshihao163@163.com 
	> Created Time: Mon 15 Apr 2019 03:11:29 PM CST
 ************************************************************************/

/*命名管道的基本使用*/

#include<stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>

int main(){
	//int mkfifo(const char *pathname, mode_t mode);
	//	pathname:   命名管道文件路径名
	//	mode:       创建文件时的权限
	//	返回值：成功：0  失败：-1
	umask(0);
	char *fifo = "./test.fifo";
	int ret = mkfifo(fifo, 0664);
	if(ret < 0){
		//出现错误，如果错误原因不是因为文件已存在，则报错退出
		if(errno != EEXIST){
			perror("mkfifo error");
			return -1;
		}
	}
	printf("i want you, guoxin!\n");
	int fd = open(fifo, O_RDONLY);
	if(fd < 0){
		perror("open error");
		return -1;
	}
	printf("open fifo success!");
	while(1){
		char buf[1024] = {0};
		int ret = read(fd, buf, 1023);
		if(ret > 0){
			printf("client say:[%s]\n", buf);
		}else if(ret == 0){
			printf("write close!\n");
			return -1;
		}else{
			perror("read error");
			return -1;
		}
	}
	close(fd);
	return 0;
}

写端：

/*************************************************************************
	> File Name: fifo_write.c
	> Author: ssh
	> Mail: sunshihao163@163.com 
	> Created Time: Mon 15 Apr 2019 03:32:29 PM CST
 ************************************************************************/

/*命名管道的基本使用*/

#include<stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>

int main(){
	//int mkfifo(const char *pathname, mode_t mode);
	//	pathname:   命名管道文件路径名
	//	mode：      创建文件时的权限
	//	返回值： 成功：0  失败： -1
	umask(0);
	char *fifo = "./test.fifo";
	int ret = mkfifo(fifo, 0664);
	if(ret < 0){
		//出先错误，如果错误原因不是因为文件已经存在，则报错退出
		if(errno != EEXIST){
			perror("fifo error");
			return -1;
		}
	}
	printf("fifo success!");
	int fd = open(fifo, O_WRONLY);
	if(fd < 0){
		perror("open error");
		return -1;
	}
	printf("open fifo success!");
	while(1){
		char buf[1024] = {0};
		scanf("%s", buf);
		write(fd, buf, strlen(buf));
		printf("write buf:[%s]\n", buf);
	}
	close(fd);
	return 0;
}

    2>共享内存

        共享内存是进程通信方式中最快的一种；

        

        共享内存通信原理：在物理内存中开辟一块空间，并且将空间映射到各个进程的虚拟地址空间；这时候进程就可以通过虚拟地址直接对内存进行操作；相较于其他通信方式（将数据拷贝内核态，用的时候再从内核态拷贝到用户态）少了两步用户态/内核态之间的数据拷贝过程，因此最快。

    共享内存的操作步骤：

        1.创建共享内存---指定标识符，大小，权限---句柄                shmget

        2.将共享内存映射到虚拟地址空间---句柄，首地址                shmat

        3.进行内存的任意操作---memcpy，printf  

        4.解除映射关系                                                                      shmdt

        5.删除共享内存                                                                      shmctl

    ipcs：查看所有的进程间通信方式

        ipcs -m  查看共享内存     ipcs -s  查看信号量    ipcs -q  查看消息队列

    ipcrm：删除进程间通信方式

        ipcrm -m shmid（共享内存id）

代码实现共享内存：

    读端：

/*************************************************************************
	> File Name: shm_read.c
	> Author: ssh
	> Mail: sunshihao163@163.com 
	> Created Time: Mon 15 Apr 2019 03:51:10 PM CST
 ************************************************************************/

/*共享内存的基本使用*/

#include<stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#include <sys/shm.h>
#define IPC_KEY 0x12345678
#define PROJ_ID 0x12345678
#define SHM_SIZE 4096
int main(){
	//1.创建/打开共享内存
	//key_t ftok(const char *pathname, int proj_id);
	//	通过文件名与一个proj_id生成一个key值
	//int shmget(key_t key, size_t size, int shmflg);
	//	key：	共享内存标识符
	//	size：	共享内存大小
	//	shmflg：选项标志
	//		IPC_CREAT	存在则打开，不存在则创建
	//		ICP_EXCL	与IPC_CREAT同用，若存在则报错，不存在则创建
	//		mode_flags	权限
	//	返回值：句柄：正整数	失败：-1
	//	key_t key = ftok(".", PROJ_ID);
	int shmid = shmget(IPC_KEY, SHM_SIZE, IPC_CREAT|0664);
	if(shmid < 0){
		perror("shmid error");
		return -1;
	}
	//2.将共享内存映射到虚拟地址空间
	//void *shmat(int shmid, const void *shmaddr, int shmflg);
	//	shmid:	共享内存创建返回的句柄
	//	shmaddr:映射首地址-通常置NULL
	//	shmflg:	
	//		0		   可读可写
	//		SHM_RDONLY 只读
	//	返回值： 成功：映射首地址    失败：(void*)-1
	char *shm_start = (char*)shmat(shmid, NULL, 0);
	if(shm_start == (void*)-1){
		perror("shmat erroe");
		return -1;
	}
	//3.进行内存操作
	int i = 0;
	while(1){
		printf("%s\n", shm_start);
		sleep(1);
	}
	//4.解除映射关系
	//int shmdt(const void *shmaddr);
	//	shmaddr:	映射首地址
	//	返回值：成功：0		失败：-1
	shmdt(shm_start);
	//5.删除共享内存
	//int shmctl(int shmid, int cmd, struct shmid_ds *buf);
	//	shmid:	句柄
	//	cmd:	操作
	//		IPC_RMID	删除共享内存
	//	buf:	设置/获取属性信息
	//		想获取传入首地址，不想获取了置NULL
	//	共享内存并不会被立即删除，而是判断当前连接数，若不为0，则拒绝后
	//	续连接，直到为0的时候才会删除这块共享内存
	shmctl(shmid, IPC_RMID, NULL);
	return 0;
}

写端：

/*************************************************************************
	> File Name: shm_read.c
	> Author: ssh
	> Mail: sunshihao163@163.com 
	> Created Time: Mon 15 Apr 2019 03:51:10 PM CST
 ************************************************************************/

/*共享内存的基本使用*/

#include<stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#include <sys/shm.h>
#define IPC_KEY 0x12345678
#define PROJ_ID 0x12345678
#define SHM_SIZE 4096
int main(){
	//1.创建/打开共享内存
	//key_t ftok(const char *pathname, int proj_id);
	//	通过文件名与一个proj_id生成一个key值
	//int shmget(key_t key, size_t size, int shmflg);
	//	key：	共享内存标识符
	//	size：	共享内存大小
	//	shmflg：选项标志
	//		IPC_CREAT	存在则打开，不存在则创建
	//		ICP_EXCL	与IPC_CREAT同用，若存在则报错，不存在则创建
	//		mode_flags	权限
	//	返回值：句柄：正整数	失败：-1
	//	key_t key = ftok(".", PROJ_ID);
	int shmid = shmget(IPC_KEY, SHM_SIZE, IPC_CREAT|0664);
	if(shmid < 0){
		perror("shmid error");
		return -1;
	}
	//2.将共享内存映射到虚拟地址空间
	//void *shmat(int shmid, const void *shmaddr, int shmflg);
	//	shmid:	共享内存创建返回的句柄
	//	shmaddr:映射首地址-通常置NULL
	//	shmflg:	
	//		0		   可读可写
	//		SHM_RDONLY 只读
	//	返回值： 成功：映射首地址    失败：(void*)-1
	char *shm_start = (char*)shmat(shmid, NULL, 0);
	if(shm_start == (void*)-1){
		perror("shmat erroe");
		return -1;
	}
	//3.进行内存操作
	int i = 0;
	while(1){
		sprintf(shm_start, "ni hao!", i++);
		sleep(1);
	}
	//4.解除映射关系
	//int shmdt(const void *shmaddr);
	//	shmaddr:	映射首地址
	//	返回值：成功：0		失败：-1
	shmdt(shm_start);
	//5.删除共享内存
	//int shmctl(int shmid, int cmd, struct shmid_ds *buf);
	//	shmid:	句柄
	//	cmd:	操作
	//		IPC_RMID	删除共享内存
	//	buf:	设置/获取属性信息
	//		想获取传入首地址，不想获取了置NULL
	//	共享内存并不会被立即删除，而是判断当前连接数，若不为0，则拒绝后
	//	续连接，直到为0的时候才会删除这块共享内存
	shmctl(shmid, IPC_RMID, NULL);
	return 0;
}

3.消息队列

    1.概述

        ·消息对列提供了一个从一个进程向另一个进程发送一块数据的方法

        ·每个数据块都被认为是一个有类型，接受者进程接受的数据可以有不同的类型值

        ·消息队列也有管道一样的不足，就是每个消息的最大长度是有上限的（MSGMAX），每个消息队列的总的字节数是由上限的（MSGMNB），系统上消息队列的总数也是有一个上限（MSGMNI）

    2.消息队列函数

        创建和访问一个消息队列：    int msgget(key_t key, int msgflg);

            参数：key：某个消息队列的名字

                       msgflg：由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的

            返回值：成功：非负整数      失败：-1

4.信号量（主要用于同步有互斥）

    进程互斥

        ·由于各进程要求共享资源，而且有些资源需要互斥使用，因此各进程间竞争使用这些资源，进程的这种关系为进程的互斥

        ·系统中某些资源一个只允许一个进程使用，称这样的资源为临界资源或者互斥资源

        ·在进程中涉及互斥资源的进程段叫临界区

Linux下进程通信与FIFO操作详解
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
09-19 793
在Linux系统中，进程间通信（Inter-Process Communication, IPC）是操作系统提供的一种机制，允许不同的进程之间交换数据或信号。这种机制对于实现多任务处理和多进程协作至关重要。Linux提供了多种IPC方式，包括管道、信号、共享内存、消息队列、信号量集以及套接字（Socket）等。本文将详细介绍Linux下进程通信的一种特殊方式——命名管道（Named Pipes），也称为FIFO（First In, First Out），并展示如何在C语言中使用命名管道进行进程间通信。
Linux-进程间通信
AI_ELF的博客
08-23 7328
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
Linux环境编程进程间通信机制，玩转Linux，理解更透彻！
陆海潘江的博客
08-28 2173
玩转Linux编程，这篇记录总结学习，理解进程间通信机制，进程的执行顺序和关系，同步互斥问题。Linux系统调用函数的认识和使用更进一步掌握相关Linux知识。
Linux进程间通信
最新发布
mastershooter的博客
10-16 978
管道是Unix中最古老的进程间通信形式，我们把一个进程连接到另一个进程的数据流称为一个“管道”。我们可以在linux中查看登录用户个数我们可以知道，who和wc是两个命令，首先who进程通过标准输出流将数据打到“管道”中，wc进程再从“管道”中读取数据，从而完成数据的处理who命令是查看云服务器的登录用户（一行显示一个），wc -l用来统计行数所以输出的是用户的个数。
linux两个进程通过共享内存通信例子
techenliu的博客
09-05 111
linux共享内存通信
Linux系统-进程间通信
~
10-11 3651
本章主要讲解学习Linux中本系统下的进程间通信概念：进程间通信简称IPC（Inter process communication），进程间通信就是在不同进程之间传播或交换信息进程间通信目的：数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）
实验四：Linux下进程管道通信.docx
04-13
**实验四：Linux下进程管道通信** 实验的目标是理解和掌握Linux操作系统中进程间通信的管道机制，通过系统调用pipe()实现数据交换。管道是一种特殊类型的文件，它允许相关进程之间进行单向通信。在这个实验中，我们...
Linux下进程通信的八种方法.docx
04-20
本文将详细阐述Linux下的八种进程通信方法，帮助读者理解并掌握这些技术。 1. **管道(Pipe)**： 管道是一种半双工通信方式，允许一个进程（发送方）将数据传递给另一个与它有共同祖先的进程（接收方）。数据以字节...
实验 Linux进程通信的参考答案
07-05
实验 Linux 进程通信的参考答案 Linux 进程通信是指在操作系统中，多个进程之间进行数据交换和同步的机制。在 Linux 中，进程通信可以通过信号、管道和共享内存等方式实现。 一、信号机制 在 Linux 中，信号是一...
Linux进程间通信方式之socket使用实例
09-15
### Linux进程间通信方式之socket使用实例详解 #### 一、引言 在现代操作系统中，进程间的通信（IPC）是实现多进程协同工作的重要手段之一。Linux提供了多种进程间通信的方法，包括信号量、消息队列、共享内存以及...
【Linux】进程间通信
Edward_Asia的博客
05-02 1万+
目录 1. 进程间通信 1.1. 进程间通信的目的 1.2. 如何实现进程间通信 2. 管道通信 2.1. 匿名管道 2.1.1 创建匿名管道 2.1.2 . 深入理解匿名管道 2.2. 命名管道 2.2.1. 创建命名管道 3. system V 标准进程间通信 3.1. 共享内存 3.1.1. 实现原理 3.1.2. 代码实现 3.2. 消息队列(了解) 3.2.1 实现原理 3.3. 信号量(了解) 3.3.1. 实现原理 1. 进程间通信 1.1.
Linux下的进程间通信（1）
weixin_45407386的博客
10-15 541
IPC(进程间通信) Linux下的多个进程间的通信机制叫做IPC，它是多个进程之间进行互相沟通的一种方法。通过进程间通信实现不同进程之间传播和交换信息。 进程间通信（IPC）的目的总结 1：数据传输 2：资源共享 3：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件 4：进程控制 进程间通信的方式 在Linux下有多个进程间通信的方法：半双工管道、FIFO（命名管道）、消息队...
进程间的通讯(IPC)方式
weixin_34221332的博客
10-09 105
为什么要进行进程间的通讯IPC (Inter-process communication)数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几M字节之间共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。资源共享：...
linux系统调用出错处理perror（）
luoyir1997的博客
09-13 573
1.haha.log不存在   2.我们试图打开haha.log #include&lt;stdio.h&gt; #include &lt;sys/types.h&gt; #include &lt;sys/stat.h&gt; #include &lt;fcntl.h&gt; ...
进程间通信
波风水门的博客
04-07 332
目录 为什么进程间不能直接通信？ 因为进程之间具有独立性，每个进程访问的都是自己的独立的虚拟地址空间，使用的都是虚拟地址，通过页表映射到物理内存，因此就算将数据的内存交给其他进程，它们也无法使用，当然其实也是无法直接给的 只能通过操作系统提供的几种方式来进行： 本质上来说是操作系统为多个进程提供了一处公共的数据传输媒介，这个媒介就是内存； 因为通信场景不同，因此提供了许多方式： 管道：用于传输数据 特性：半双工通信——可以选择方向的单向通信 本质：就是内核中的一块缓冲区(内存) 分类： 匿名管道：管
总结Linux下进程间通信的几种方式方法
热门推荐
菜鸟不会飞
09-21 2万+
Linux下进程通信的八种方法： 管道(pipe)， 命名管道(FIFO)， 内存映射(mapped memeory)， 消息队列(message queue)， 共享内存(shared memory)， 信号量(semaphore)， 信号(signal) ，套接字(Socket)     (1) 管道（pipe）：               管道允许一个进程和另一个与它有共...
Linux下通过信号量保证共享内存方式通信同步
君君的博客
08-31 843
1编译 POSIX 信号量程序需要加上-pthread 参数。 2. 创建或打开有名信号量 使用有名信号量前需要先创建或打开信号量, 可使用 sem_open()函数来完成。 sem_open() 函数的原型如下: #include <fcntl.h> #include <sys/stat.h> #include <semaphore.h> sem_t *sem_open(const char *name, int oflag); sem_t *sem_open(co..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值