Linux系统编程--(三)进程间通信

最新推荐文章于 2023-07-22 15:59:28 发布
最新推荐文章于 2023-07-22 15:59:28 发布
阅读量162 收藏
点赞数
分类专栏： 运维 文章标签： linux 服务器 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38756978/article/details/128196223
版权

一.进程间通讯

1.1 什么是进程间通信

我们运行起来的进程，相互之间资源是独立的，不能在一个进程中直接访问另一个进程的资源。
但是很多时候不同的进程需要进行信息的交互和状态的传递等，譬如数据传输，一个进程需要将它的数据发送给另一个进程，或者多个进程间资源共享，或者一个进程需要控制另一个进程的执行，再或者，一个进程要给另一个进程发送消息等，就需要进程间通信( IPC：Inter Processes Communication )。

1.2 进程间通信的方式

进程间通信的方式有很多，文件、管道、信号、共享内存映射、消息队列、套接字、命名管道等。这里说管道pipe，命名管道fifo，共享内存映射。

二.管道PIPE

2.1 管道概述

管道是一种最基本的IPC机制，也称匿名管道、无名管道，应用于有血缘关系的进程之间，完成数据传递。
所有的 UNIX 系统都支持这种通信机制。

管道的本质是一块内核缓冲区，由两个文件描述符引用，一个表示读端，一个表示写端。
管道是半双工，规定数据从管道的写端流入管道，从读端流出，当两个进程都终结的时候，管道也自动消失，管道的读端和写端默认都是阻塞的。

管道的数据一旦被读走，便不在管道中存在，不可反复读取，数据只能在一个方向上流动，若要实现双向流动，必须使用两个管道。

只能在有血缘关系的进程间使用管道

创建管道非常简单，调用pipe函数即可

2.2 pipe函数

#include <unistd.h>
​
int pipe(int pipefd[2]);
功能：创建无名管道。
​
参数：
    pipefd : 为 int 型数组的首地址，其存放了管道的文件描述符 pipefd[0]、pipefd[1]。
    
    当一个管道建立时，它会创建两个文件描述符 fd[0] 和 fd[1]。其中 fd[0] 固定用于读管道，而 fd[1] 固定用于写管道。一般文件 I/O的函数都可以用来操作管道(lseek() 除外)。
​
返回值：
    成功：0
    失败：-1

代码示例

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>

/* pipe函数演示 */
int main(){
    int fd[2];
    int ret = pipe(fd); //创建管道

    if(ret<0){ 
        //创建管道失败
        perror("pipe");
        return -1;
    }

    pid_t pid = fork();
    if(pid < 0){
        // 创建进程失败
        perror("fork");
        return -1;
    }else if(pid > 0){
        // 父进程 
        close(fd[0]);
        // 父进程写入fd[1]
        write(fd[1],"hello",strlen("hello"));
        wait(NULL);

    }else {
        // 子进程读取
        char buf[128];
        memset(buf,0,sizeof(buf));
        int n = read(fd[0],buf,sizeof(buf));
        printf("%s\n",buf);
    }
}

2.3 管道的读写行为注意事项

这里假定都是阻塞I/O操作，我们使用管道需要注意以下4种特殊情况：

  1. 如果所有指向管道写端的文件描述符都关闭了，而仍然有进程从管道的读端读数据，那么管道中剩余的数据都被读取后，再次read会返回0，就像读到文件末尾一样。

  2. 如果有指向管道写端的文件描述符没关闭，而持有管道写端的进程也没有向管道中写数据，这时有进程从管道读端读数据，那么管道中剩余的数据都被读取后，再次read会阻塞，直到管道中有数据可读了才读取数据并返回。

  3. 如果所有指向管道读端的文件描述符都关闭了，这时有进程向管道的写端write，那么该进程会收到信号SIGPIPE，通常会导致进程异常终止。当然也可以对SIGPIPE信号实施捕捉，不终止进程。具体方法信号章节详细介绍。

  4. 如果有指向管道读端的文件描述符没关闭，而持有管道读端的进程也没有从管道中读数据，这时有进程向管道写端写数据，那么在管道被写满时再次write会阻塞，直到管道中有空位置了才写入数据并返回。

默认管道的读写两端为阻塞的IO操作，但也可以设置为非阻塞，方法也很简单，就是使用fcntl函数，设置O_NONBLOCK标志标志。

//获取原来的flags
int flags = fcntl(fd[0], F_GETFL);
// 设置新的flags
flag |= O_NONBLOCK;
// flags = flags | O_NONBLOCK;
fcntl(fd[0], F_SETFL, flags);

2.4 查看缓冲区

管道本质是一个内核缓冲区，那么如何查看缓冲区大小呢？
1）ulimit -a

(base) zhaow@zhaow-610:~$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 62944
max locked memory       (kbytes, -l) 65536
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8 // 管道缓冲区大小
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 62944
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

2）fpathconf函数

#include <unistd.h>
​
long fpathconf(int fd, int name);
功能：该函数可以通过name参数查看不同的属性值
参数：
    fd：文件描述符
    name：
        _PC_PIPE_BUF，查看管道缓冲区大小
        _PC_NAME_MAX，文件名字字节数的上限
返回值：
    成功：根据name返回的值的意义也不同。
    失败： -1

示例

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>

int main(){
    int fd[2];
    int ret = pipe(fd);
    if(ret <0){
        perror("pipe");
        return -1;
    }
    printf("pipe read size==[%ld]\n", fpathconf(fd[0], _PC_PIPE_BUF));
	printf("pipe write size==[%ld]\n", fpathconf(fd[1], _PC_PIPE_BUF));

	return 0;

}

三.命名管道（FIFO）

3.1 概述

管道(pipe)只能用于“有血缘关系”的进程间通信，为了弥补这个缺陷，提出了命名管道（FIFO），也叫有名管道、FIFO文件。

命名管道（FIFO）提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，这样即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信，因此，通过 FIFO 不相关的进程也能交换数据。

FIFO是Linux基础文件类型中的一种（文件类型为p，可通过ls -l查看文件类型）。
FIFO文件在磁盘上没有数据块，仅仅用来标识内核中一条通道，进程打开这个文件进行read/write，实际上是在读写内核缓冲区。

3.2 创建fifo

1）命令mkfifo

(base) zhaow@zhaow-610:demo$ mkfifo myfifo
(base) zhaow@zhaow-610:demo$ ls -l
总用量 0
prw-rw-r-- 1 zhaow zhaow 0 8月  21 02:42 myfifo  //文件类型 p

2）函数mkfifo

#include <sys/types.h>
#include <sys/stat.h>
​
int mkfifo(const char *pathname, mode_t mode);
功能：
    命名管道的创建。
参数：
    pathname : 普通的路径名，也就是创建后 FIFO 的名字。
    mode : 文件的权限，与打开普通文件的 open() 函数中的 mode 参数相同。(0666)
返回值：
    成功：0   状态码
    失败：如果文件已经存在，则会出错且返回 -1。

3.3 代码示例

进程A 写入

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

int main()
{
	//创建fifo文件
	// 1.检查是否存在，不存在则创建
	int ret = access("./myfifo", F_OK);
	if(ret!=0)
	{		
		ret = mkfifo("./myfifo", 0777);
		if(ret<0)
		{
			perror("mkfifo error");
			return -1;
		}
	}

	//打开文件
	int fd = open("./myfifo", O_RDWR);
	if(fd<0)
	{
		perror("open error");
		return -1;
	}

	//写fifo文件
	int i = 0;
	char buf[64];
	while(1)
	{
		memset(buf, 0x00, sizeof(buf));
		sprintf(buf, "%d:%s", i, "hello world");
		write(fd, buf, strlen(buf));
		sleep(1);

		i++;
	}

	
	close(fd);


	return 0;
}

进程B 读取

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


int main(){
    // 1.检查要创建的fifo文件是否存在，若不存在则创建
    int ret = access("./myfifo",F_OK);
    if(ret != 0){
        ret = mkfifo("./myfifo",0777);
        if(ret < 0){
            perror("mkfifo");
            return -1;
        }
    }

    // 打开fifo

    int fd = open("./myfifo",O_RDWR);
    if(fd<0){
        perror("open");
        return -1;
    }

    // 读取
    int n;
    char buf[128];
    while (1)
    {
        memset(buf,0x00,sizeof(buf));
        n = read(fd,buf,sizeof(buf));
        printf("buf=[%s]\n",buf);
    }
    
    close(fd);

    return 0;
}

四.共享存储映射

4.1 概述

存储映射I/O (Memory-mapped I/O) 就是使一个磁盘文件与存储空间中的一个缓冲区相映射。
从缓冲区中取数据，就如同读文件中的相应字节；同样，将数据写入缓冲区，则会将数据写入文件。

4.2 存储映射函数

1)mmap

#include <sys/mman.h>
​
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
1 用途:一个文件或者其它对象映射进内存)
2 参数说明：
    addr :  指定映射的起始地址, 通常设为NULL, 由系统指定
    length：映射到内存的文件长度
    prot：  映射区的保护方式, 常用的三种
        1) 读：PROT_READ
        2) 写：PROT_WRITE
        3) 读写：PROT_READ | PROT_WRITE
    flags：  映射区的特性, 可以是
        1) MAP_SHARED : 写入映射区的数据会复制回文件, 且允许其他映射该文件的进程共享。
        2) MAP_PRIVATE : 对映射区的写入操作会产生一个映射区的复制(copy - on - write), 对此区域所做的修改不会写回原文件。
    fd：由open返回的文件描述符, 代表要映射的文件。
    offset：以文件开始处的偏移量, 必须是4k的整数倍, 通常为0, 表示从文件头开始映射
返回值：
    成功：返回创建的映射区首地址
    失败：MAP_FAILED宏
​

2)munmap


#include <sys/mman.h>
​
int munmap(void *addr, size_t length);
功能：
    释放内存映射区
参数：
    addr：使用mmap函数创建的映射区的首地址
    length：映射区的大小
返回值：
    成功：0
    失败：-1

代码示例 父子进程间通信

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>

int main(){
    int fd = open("./ts.log",O_RDWR); //当映射文件大小为0时，不能创建映射区,所以，用于映射的文件必须要有实际大小;
    if(fd < 0){
        perror("open");
        return -1;
    }

    int len = lseek(fd,0,SEEK_END);

    void * addr = mmap(NULL,len,PROT_READ |PROT_WRITE,MAP_SHARED,fd,0);

    if(addr == MAP_FAILED){ // mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作
        perror("mmap");
        return -1;
    }

    close(fd); //映射区的释放与文件关闭无关，只要映射建立成功，文件可以立即关闭。

    pid_t pid = fork();
    if(pid < 0){
        perror("fork");
        return -1;
    }else if(pid > 0){
        memcpy(addr,"hello",strlen("hello"));
        wait(NULL);
    }else{
        char buf[64];
        memset(buf,0x00,sizeof(buf));
        memcpy(buf,addr,5);
        printf("%s\n",buf);
    }

    return 0;
}

4.3 匿名映射实现父子进程通信

使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易，但比较麻烦的是，每次创建映射区一定要依赖一个文件才能实现，为了建立映射区要open一个temp文件，创建好了再unlink、close掉，很麻烦。
Linux系统提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定。

int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
参数说明：
	4"随意，该位置表示映射区大小，可依实际需要填写。
	MAP_ANONYMOUS和MAP_ANON这两个宏是Linux操作系统特有的宏。

代码示例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/mman.h>

int main(){
    void * addr = mmap(NULL,4096,PROT_READ|PROT_WRITE,MAP_SHARED | MAP_ANONYMOUS,-1,0);
    if(addr==MAP_FAILED)
	{
		perror("mmap");
		return -1;
	}

    pid_t pid  = fork();
    if(pid < 0){
        perror("fork");
        return -1;
    }else if(pid > 0){
        memcpy(addr,"hello",strlen("hello"));
        wait(NULL);
    }else{
        char buf[64];
        memset(buf,0x00,strlen(buf));
        memcpy(buf,addr,5);
        printf("%s\n",buf);
    }

    return 0;
}
leafgood
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程间通信（编程版）
weixin_42078660的博客
11-22 378
进程间通信（编程版） 除学linux，内容较为粗糙，如有问题，请多多指教。 此篇重点在编程上，对于理论分析较少，后续会专门分析理论。 进程间通信：管道，信号量，共享内存，消息队列，套接字。 1.管道： 1.简诉： 管道：有名管道和无名管道 有名管道：用于任意两个进程中间 无名管道：用于父...
进程间通信编程
weixin_43296982的博客
03-05 1213
1.进程间通信方式概述 进程间通信是在不同进程之间传播或者交换信息。 进程间通信方法有:管道(无名和有名管道)，消息队列，信号量，共享内存，信号，套接字等 进程间通信的目的: 1、数据传输，2、共享数据，3、通知事件，4、资源共享，5、进程控制 2.管道通信 管道有无名管道和有名管道，无名管道是适用于父子进程或者兄弟进程之间，进程之间存在联系的，可以用管道。 有名管道，不仅父子，兄弟进程可以使用，没有关系的两个进程也可以使用，有名管道克服了管道没有名字的限制。所以才可以字无关系的进程之间建立通信。传递的数据
进程间通信（系统编程）
嵌入式C
03-27 443
进程间通信：用户空间不可以通信，只在内核中通信 线程间通信：用户空间可以通信，通过全局变量进行通信 要想实现父进程先运行子进程后运行，可以加一个全局变量或者局部变量阻塞子进程的运行。 通信方式：管道、信号、IPC(共享内存，消息队列，信号灯) 占用内存的只有目录文件，软链接，套接字文件？ 有名管道，字符设备，块设备，套接字他们不占用磁盘空间，只有文件节点 atoi(字符串)：将字符串转换为数字 sprintf(buf,"%d",num);将数字转化为字符串 无名管道：pipe(pipefd..
Linux进程间通信编程
qq_44836035的博客
03-05 481
进程间通信方式 现在Linux使用的进程间通信方式包括： 1、管道（pipe）和有名管道（FIFO） 2、信号（signal） 3、消息队列 4、共享内存 5、信号量 6、套接字（socket） 1.管道： 管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。 数据被一个进程读出后，将被从管道中删除。进程试图读空管道时，进程将阻塞。同样，管道已经满时，进程再试图向管道写入数据，进程
Linux系统进程间通信编程
weixin_55179981的博客
10-26 216
进程间通信
Linux系统编程-进程间通信1
08-08
在Linux系统编程中，进程间通信（IPC，InterProcess Communication）是实现不同进程间数据交换的关键技术。由于每个进程都有其独立的用户地址空间，它们无法直接访问彼此的数据。为了解决这个问题，操作系统提供了...
linux系统编程_linux系统编程-中文_
10-04
进程间通信（IPC）也是Linux系统编程的重要部分，包括管道、消息队列、共享内存、信号量和套接字等方法。了解这些机制如何协同工作，可以帮助你设计出高效的多进程和多线程程序。 最后，理解Makefile和构建系统是...
linux系统编程-进程间通信
04-19
Linux 系统编程 - 进程间通信 Linux 系统编程中，进程间通信（IPC）是指不同的进程之间交换数据和信息的机制。由于每个进程都有其自己的用户地址空间，所以进程之间不能直接访问对方的变量，需要通过内核提供的机制...
linux系统编程--进程间通信--管道
08-21
Linux系统编程--进程间通信--管道 在Linux系统中，进程间通信是指不同的进程之间交换数据和信息的方式。由于进程之间的地址空间相对独立，不能像线程之间通过全局变量通信，因此需要其他机制来实现进程间通信。 ...
01--Linux系统编程-进程间通信.docx
11-10
本资料是学习Linux系统编程进阶的利器，让你在巩固基础的同时，达到能力技能的提高，轻松驾驭Linux系统编程的系列知识，其中具体分析了各个函数的具体用法及参数的使用，各个希望在Linux服务器开发方面有建树的朋友...
VC++ 四种进程间通信的完整实例
05-11
VC++ 四种进程间通信的完整实例，一般来说，进程通信采取四种形式：剪贴板、匿名管道、命名管道、邮槽。孙鑫将带你用实例来验证这四种方式的优略性，进而帮助VC编程者熟悉掌握进程间通信的方方面面，并附有孙鑫老师的讲义，欢迎参阅。
进程编程,进程间通信
weixin_51757701的博客
04-05 1236
进程编程一、进程的概念1.什么是程序：2.什么是进程 ：3.进程内容：4.进程类型：5.进程状态二、查看进程信息三 、进程相关命令四、进程相关命令1.进程的创建-----fork()2.父子进程的关系3.进程结束 exit/_exit4.exec 函数族① execl/execlp② execv/execvp③system5.进程回收①pid_t wait(int *status);② pid_t waitpid(pid_t pid ,int *status,int option);五、守护进程1.守护
Linux系统编程——进程间通信（一）
无夜之凛冬的博客
03-05 661
Linux系统主要的进程间通信机制如下： 无名管道（Pipe）及命名管道（Named pipe）：无名管道可用于具有父子关系进程间的通信；命名管道用于无父子关系的进程之间的通信。无父子关系的进程可将信息发送到某个命名管道中，通过管道名读取信息 信号（Signal）：进程间的高级通信方式，用于通知其他进程有何种事件发生。此外，进程可以向自身发送信号，还可获得Linux内核发出的信号。 报文（Mes...
Linux系统编程-进程间通信
touchingnotyet的博客
08-28 252
Linux系统编程-进程间通信
网络编程——进程间通信
beilizhang的博客
11-01 505
参考 《TCP/IP网络编程》 尹圣雨 进程间通信 进程间通信（Inter Process Communication）意味着两个不同进程间可以交换数据，为了完成这一点，操作系统中应提供两个进程可以同时访问的内存空间 通过管道实现进程间通信 为了完成进程间通信，需要创建管道。管道并非属于进程的资源，而是和套接字一样，属于操作系统（即不是fork函数的复制对象）。所以，两个进程通过操作系统提供的内存空间进行通信 #include <unistd.h> int pipe(int filedes
Linux系统编程——进程间的通信
NRWHF的博客
11-10 903
Linux系统编程——进程间的通信
Linux系统编程（三）进程间通信
最新发布
qq_42747843的博客
07-22 159
首先与初级信号函数一样我们均需要对捕获信号后所需要进行的动作进行定义，要实现收发消息，需要在act结构体中把sa_flag设置为SA_SIGINFO来使能数据接收功能，并且要在设置信号处理函数时设置成sigaction选项，并且要在发送消息的程序中设置好发送的数据或者信息。如图：fd[0]为读端，fd[1]为写端，在某一时刻，父进程把读端关闭，子进程把写端关闭,父进程把数据写入管道，子进程把数据从管道里读出。4消息队列可实现信息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取。
Linux 编程基础——进程间通信
DemonsYZ的博客
05-19 527
管道 管道通信的流程：在一个进程中创建管道，创建子进程，关闭多余端口，使父子进程形成单向通道，进行数据传输。 创建匿名管道函数： #include <unistd.h> int pipe(int pipefd[2]); 示例：使用pip实现父子进程间通信，子进程作为写端，父进程读出内容并打印到终端。 解释:用到的write(int fd,const void *buf,size_t count)函数：把参数buf所指的内存写入count个字节到所指的文件fd内。 #incl
linux系统编程之进程间的通信
qq_53918454的博客
11-26 684
1.无名管道：速度慢，容量有限，只有亲缘进程之间才能通信；2.有名管道：速度慢，但是任何进程间都能通信；3.消息队列：容量受系统限制，第一次读时，要考虑上次没有读完的数据问题；4.共享内存：能够容易控制容量，速度快，但要考虑同步问题；5.信号量：用来同步消息；以上就是进程间通信相关内容，有不对的地方欢迎大家批评指正。
实验六 Linux进程编程,Linux系统编程实验六：进程间通信
05-19
Linux提供了多种进程间通信的方式，包括管道、消息队列、共享内存和信号量等。在实验六中，我们将学习如何使用这些方式进行进程间通信。 1. 管道 管道是一种半双工的通信方式，它可以在两个进程之间传递数据。在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值