【Linux学习笔记】11-进程通信

已于 2022-03-06 13:42:36 修改
阅读量1k 收藏
点赞数
分类专栏： linux 文章标签： git linux bash
于 2022-03-03 19:31:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42961603/article/details/123154037
版权
本文深入探讨了进程间通信的三种主要方式：匿名管道、命名管道和共享内存。详细阐述了每种方式的工作原理、使用步骤及示例代码。匿名管道适用于有血缘关系的进程，而命名管道扩展到无血缘关系进程。共享内存则提供了快速通信的方式，但不包含同步互斥机制。消息队列允许不同类型的消息传递，确保了通信的灵活性。这些技术在系统编程和并发处理中起着关键作用。
摘要由CSDN通过智能技术生成

进程通信

1、管道

1. 匿名管道

匿名管道供具有血缘关系的进程进行通信

匿名管道通信步骤：
1、一个进程分别以读写方式打开同一个文件，这样就有两个文件描述符，一个以read方式指向该文件，一个以write方式指向该文件
2、父进程fork创建一个子进程，因为子进程创建以父进程为模版，则子进程的file_struct的fd_array与父进程一样
3、让父进程read，子进程write，则关闭父进行的write，保持父进程的read打开；关闭子进程的read，保持子进程的write打开

测试1

  1 #include <stdio.h>
  2 #include <unistd.h>
  3 
  4 int main() {
  5     int pipe_fd[2] = {0};
  6     if (pipe(pipe_fd) < 0) {
  7         perror("pipe");
  8         return 1;
  9     }
 10     printf("%d %d\n", pipe_fd[0], pipe_fd[1]);                                                                                       
 11     return 0;
 12 }
~

在这里插入图片描述
测试2

    1 #include <stdio.h>
    2 #include <unistd.h>
    3 #include <string.h>
    4 #include <sys/types.h>
    5 #include <sys/stat.h>
    6 #include <stdlib.h>
    7                                                                                                                                    
    8 
    9 int main() {
   10     int pipe_fd[2] = {0};
   11     if (pipe(pipe_fd) < 0) {
   12         perror("pipe");
   13         return 1;
   14     }
   15     printf("%d %d\n", pipe_fd[0], pipe_fd[1]);
   16     pid_t id = fork();
   17     if (id < 0) {
   18         perror("fork");
   19     }
   20     if (id == 0) { //write
   21         //child
   22         close(pipe_fd[0]);
W> 23         char *msg = "hello world, i am child process";
   24         int count = 5;
   25         while (count) {
   26             write(pipe_fd[1], msg, strlen(msg));
   27             sleep(1);
   28             count--;
   29         }
   30         close(pipe_fd[1]);
   31         exit(0);
   32     }else {     // read
   33         //parent
   34         close(pipe_fd[1]);
   35         ssize_t size = 0;
   36         char buf[64] = {0};
   37         while(1) {
   38             size = read(pipe_fd[0], buf, sizeof(buf)-1);
   39             if (size > 0) {
   40                 buf[size] = 0;
   41                 printf("parent get message from child#: %s\n", buf);
   42             } else if (size == 0) {
   43                 printf("pipe file close, child quit!\n");
   44                 break;
   45             }
   46         }
   47         close(pipe_fd[0]);
   48         int status = 0;
   49         pid_t ret = waitpid(id, &status, 0);
   50         if (ret == -1) {
   51             perror("waitpid");
   52             return 1;
   53         }
   54         printf("child is waited, the exit code is %d\n", WEXITSTATUS(status));
   55     }
   56     return 0;
   57 }

在这里插入图片描述
测试3：读端不读且关闭了read，写端会怎么样？
系统直接kill了写端，因为没人读，写就是做的无用功，系统不允许任何无用功

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


int main() {
    int pipe_fd[2] = {0};
    if (pipe(pipe_fd) < 0) {
        perror("pipe");
        return 1;
    }
    printf("%d %d\n", pipe_fd[0], pipe_fd[1]);
    pid_t id = fork();
    if (id < 0) {
        perror("fork");
    }
    if (id == 0) { //write
        //child
        close(pipe_fd[0]);
        char *msg = "hello world, i am child process";
        int count = 5;
        while (count) {
            write(pipe_fd[1], msg, strlen(msg));
            sleep(1);
            count--;
        }
        close(pipe_fd[1]);
        exit(0);
    }else {     // read
        //parent
        close(pipe_fd[1]);
        ssize_t size = 0;
        char buf[64] = {0};
        while(1) {
            size = read(pipe_fd[0], buf, sizeof(buf)-1);
            if (size > 0) {
                buf[size] = 0;
                printf("parent get message from child#: %s\n", buf);
            } else if (size == 0) {
                printf("pipe file close, child quit!\n");
                break;
            }else{
                break;
            }
            close(pipe_fd[0]);
        }
        //close(pipe_fd[0]);
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        if (ret == -1) {
            perror("waitpid");
            return 1;
        }
        printf("child is waited, the sig code is %d, the exit code is %d\n", (status & 0x7F), WEXITSTATUS(status));
    }
    return 0;
}

在这里插入图片描述
管道的生命周期是随着进程的生命周期的，因为一个进程关闭了，则该进程打开的文件也会关闭

2. 命名管道

用于没有血缘关系的两个进程之间的通信
mkfifo：用于创建一个命名管道的命令，mkfifo filename可以只在命令行创建一个名为filename的命名管道文件。
但是，向filename写数据时，我们的数据并不会写到磁盘上，只会写到struct file结构体的缓冲区里。（普通文件需要将数据刷新到磁盘来持久化存储）

测试1：在创建了myfifo的命名管道文件后
在bash1里：

while :; do echo "hello world"; sleep 1; done > myfifo

在bash2里：

cat < myfifo

可以看到“hello world”在bash2中被打印出来

测试2：代码级命名管道通信

int mkfifo(const char *filename, mode_t mode)
成功返回0，失败返回-1

创建一个servre，一个client，client发消息，server接收到消息

//server.c
  1 #include "stdio.h"
  2 #include <unistd.h>
  3 #include <string.h>
  4 #include <stdlib.h>
  5 #include <sys/types.h>
  6 #include <sys/stat.h>
  7 #include <fcntl.h>
  8 
  9 #define FIFO "./fifo"
 10 
 11 int main() {
 12     int ret = mkfifo(FIFO, 0644);
 13     if (ret < 0) {
 14         perror("mkfifo");
 15     }
 16     int fd = open(FIFO, O_RDONLY);
 17     if (fd < 0) {
 18         perror("open");
 19         return 1;
 20     }
 21 
 22     char buf[64] = {0};
 23 
 24     while (1) {
 25         ssize_t s = read(fd, buf, sizeof(buf)-1);
 26         if (s > 0) {
 27             buf[s] = 0;
 28             printf("parent get message from client#: %s", buf);                                                                      
 29         }else if(s == 0) {
 30             printf("client quit\n");
 31             break;
 32         }else {
 33             break;
 34         }
 35     }
 36     close(fd);
 37     return 0;
 38 }

//client.c
  1 #include "stdio.h"
  2 #include <unistd.h>
  3 #include <string.h>
  4 #include <stdlib.h>
  5 #include <sys/types.h>
  6 #include <sys/stat.h>
  7 #include <fcntl.h>
  8 
  9 #define FIFO "./fifo"
 10 
 11 int main() {
 12     int fd = open(FIFO, O_WRONLY);
 13     if (fd < 0) {
 14         perror("open");
 15         return 1;
 16     }
 17 
 18     char buf[128];
 19 
 20     while (1) {
 21         printf("please enter# ");
 22         fflush(stdout);
 23         buf[0] = 0;
 24         ssize_t s = read(0, buf, sizeof(buf)-1);                                                                                     
 25         if (s > 0) {
 26             buf[s] = 0;
 27             write(fd, buf, strlen(buf));
 28         }else if(s == 0) {
 29             break;
 30         }else {
 31             break;
 32         }
 33     }
 34     close(fd);
 35     return 0;
 36 }

请添加图片描述
请添加图片描述

2、共享内存

不需要read/write等接口读和写，因为已经映射到内存了
共享内存：在物理内存上申请的一段空间，由OS将其分别通过两个进程的页表映射到各自的虚拟内存中（进程双方就看到了同一份资源），然后将地址返回给用户，就可以通过这段空间进行通信。
系统会对所有的共享内存进行管理：先描述再组织

1. 创建共享内存（man shmget）

创建共享内存
shmflg后面也可以跟权限：0644，一样的用｜分隔

grep -ER ‘IPC_CREAT’ /usr/include/：查看IPC_CREAT
可以看到其定义在vim /usr/include/bits/ipc.h中
在这里插入图片描述

2. 获取唯一性key（man get）

在这里插入图片描述
只要两个进程ftok参数填一样的，那个获得的返回值key也是一样的，也就能指示同一个共享内存（管理共享内存的struct中存在标识它自己的key字段）

3. 删除共享内存（man shmctl）

在这里插入图片描述
在*ctl中可以查看描述其对应资源的结构体（共享内存/消息队列/信号量）
在这里插入图片描述

第一个参数为共享内存标识码，第二个参数设置为IPC_RMID表示删除共享内存，最后一个暂时设置为NULL

4. 将进程关联到共享内存/去关联共享内存（man shmat）

在这里插入图片描述
第二个参数和第三个参数暂时设为NULL和0

// 用于不断查看共享内存信息
while :; do ipcs -m | head -3 && ipcs -m | grep "xupeng";echo "###########"; sleep 1; done

5. 获取共享内存中的内容

（因为已经通过shmat获得到了虚拟内存的地址，直接像打印buffer也就是数组中的内容一样打印）
在这里插入图片描述

6. 把内容写入共享内存

在这里插入图片描述

共享内存生命周期随OS
共享内存不提供任何同步互斥，彼此独立
共享内存通信是最快的；没有拷贝到文件中的操作，没有用户态内核态的转换
shim是用户层操作的概念
key是系统表示唯一性

grep -ER ‘struct ipc_perm’ /usr/include/ ：查找ipc_perm
在这里插入图片描述

3、消息队列

1. 获取消息队列（man msgget）

在这里插入图片描述
参数与shmget一样

2. 删除消息队列（man msgctl）

在这里插入图片描述
信号的前缀是sem，semget/semctl…
发送消息时的结构体中的类型，可以指定两个进程进行通信，只有发送类型和接收类型一样的才能进行通信(type=0表示任何进程都可以接收这个消息)。

//client.c
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
#include "unistd.h"
#include "fcntl.h"
#include "sys/ipc.h"
#include "sys/msg.h"

#define SIZE 100

struct Buf{
    long type;
    char text[SIZE];
};


int main() {
    key_t key = ftok("/home/xupeng", 10);
    if (key < 0) {
        perror("ftok");
        return 2;
    }

    int msgid = msgget(key, IPC_CREAT | 0644);
    if (msgid < 0) {
        perror("msgid");
        return 2;
    }

    struct Buf bf;
    bzero(&bf, sizeof(bf));
    bf.type = 1;
    bf.text[0] = 0;
    strcpy(bf.text, "hello world");

    msgsnd(msgid, &bf, strlen(bf.text), 1);


    return 0;
}

//server.c
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
#include "unistd.h"
#include "fcntl.h"
#include "sys/ipc.h"
#include "sys/msg.h"

#define SIZE 100

struct Buf{
    long type;
    char text[SIZE];
};


int main() {
    key_t key = ftok("/home/xupeng", 10);
    if (key < 0) {
        perror("ftok");
        return 2;
    }

    int msgid = msgget(key, IPC_CREAT);
    if (msgid < 0) {
        perror("msgid");
        return 2;
    }

    struct Buf bf;

    size_t size = msgrcv(msgid, &bf, SIZE, 1, 0);
    printf("msgrcv return : %d", size);
    bf.text[size] = 0;
    printf("i get meg from client : %s\n", bf.text);
    

    return 0;
}
Go 鹏ya
关注
专栏目录
Linux网络编程————进程间通信
go_home_look的博客
03-21 415
管道（pipe） 管道的实质是一个内核缓冲区，进程以先进先出（FIFO， First In First Out）的方式从缓冲区存取数据：管道一端的进程顺序地将进程数据写入缓冲区，另一端的进程则顺序地读取数据，该缓冲区可以看做一个循环队列，读和写的位置都是自动增加的，一个数据只能被读一次，读出以后再缓冲区都不复存在了 局限性： 1）半双工，数据只能在一个方向流动 　　　　2）管道只能在具有公共祖先之...
Linux学习笔记-----进程间通信（管道及共享内存）
qq_41219243的博客
04-06 272
要让两个不同进程通信，前提条件是让两个进程看到同一资源。 对于进程间要相互通信，我们引入管道和共享内存概念 管道是Unix中最古老的进程间通信的形式，要让两个不同进程通信，前提条件是让两个进程看到同一资源。管道的生命周期是随进程的。 共享内存是进程通信中最快的，ipc的生命周期随内核，共享内存底层不提供任何的互斥机制。 一、匿名管道 匿名管道用于进程之间通信，且仅限于本地父子进程之间通信（兄弟、爷孙之间都可以，只要有亲缘关系），结构简单，类似于一根非水平状态的水管，一端进水另一端出水(单工)。相对于命.
linux进程间通信面试题,Golang面试之Linux系统-进程/线程
weixin_32023091的博客
04-29 224
参考进程进程process是指正在执行的程序；是程序正在运行的一个实例。它由程序指令，和从文件、其它程序中读取的数据或系统用户的输入组成。在 Linux 中主要有两种类型的进程：前台进程也称为交互式进程，这些进程由终端会话初始化和控制。换句话说，需要有一个连接到系统中的用户来启动这样的进程；它们不是作为系统功能/服务的一部分自动启动。后台进程也称为非交互式/自动进程，这些进程没有连接到终端；它们不...
Linux 进程间通信
kikajack的博客
07-01 181
Linux 进程间通信的方式可以分为三大类： 管道 信号 IPC，又可分为三类 共享内存 消息队列 信号量 管道 管道是 Linux 内核中的数据结构，类似于队列，管道中的特性如下： 数据只能读取一次，读取后消失，不可再次读 半双工通信，两端都可以用来写数据，但一端开始写数据的话，另一端只能用来读 无数据时，读会阻塞；数据写满时，会写阻塞 用过命令行的人，对管道应该不陌生。例如，查看...
linux-进程间通信
qq_53558968的博客
09-17 544
文章目录 为什么你的0，1，2号文件默认打开？ 因为bash打开了，后面的进程继承了它的file_struct，所以只要一个进程默认打开，其他的子进程都会默认打开。 为什么file结构体不会为子进程创建？ 因为file结构体属于文件，不属于进程。只是和进程关联起来罢了。 ...
Linux--消息队列
m0_59052131的博客
03-13 1708
消息队列的创建和读取相关注意事项和源代码及其执行结果。
Linux学习笔记Linux学习资料Linux教程
11-23
【linux学习笔记-13】基本进程通信--文件锁.doc 【linux学习笔记-14】基本进程通信--信号.doc 【linux学习笔记-15】基本进程通信--管道.doc 【linux学习笔记-16】shell管道重定向程序的实现.doc 【linux学习笔记-1】...
Linux学习笔记---基础篇
Fatter$hday的博客
05-04 1445
Linux学习笔记 本笔记是根据尚硅谷的Linux视频，经过自己的总结得出来的笔记，分为两个大章节，一-四章讲的是Linux的文件目录结构、vim编辑器、网络配置和系统管理、进程和服务。第二个章节是Linux的基础常用命令总结。
Linux学习笔记4---第9、10、11章
weixin_38665351的博客
10-09 2109
1005 接之前的内容Linux学习笔记3—第六七八章 Linux学习笔记4九、网路配置 九、网路配置
进程间通信简介-I.MX6U嵌入式Linux C应用编程学习笔记基于正点原子阿尔法开发板
最新发布
06-29
进程间通信简介-I.MX6U嵌入式Linux C应用编程学习笔记基于正点原子阿尔法开发板
【Linux】进程间通信--消息队列
ArchyLi
01-09 484
一、消息队列是什么消息队列提供了从一个进程向另外一个进程发送一块数据的方法，每个数据块都有相应的类型，接收者进程接收的数据块可以由不同的类型值。消息队列和管道的不同之处，是消息队列是基于消息的，而管道是基于字节流的。消息队列和命名管道一样有缺陷： 每个消息的最大长度是由上线的。 每个消息队列的总字节数是有上限的。 系统上消息队列的总数也是有上限的。 这个上限值我们可以分别在proc/sys/kcrn
【系统编程】进程间通信 --IPC(消息队列msg、共享内存shm、信号量sem）
Jason的技术探索与分享
09-24 1629
linux系统编程大纲 1. 进程概念、进程诞生与死亡、进程函数接口、进程意义。2. 进程通信方式，有名管道、无名管道、信号、消息队列、共享内存、信号量。 3. 进程信号集、如何设置阻塞属性。 4. 线程概念，线程与进程区别？线程诞生与死亡，函数接口。 5. 线程同步互斥方式，有名信号量，无名信号量，互斥锁，读写锁，条件变量。 6. 拓展 -> 线程池 -> 同时处理多个任务。 ...
共享内存 - shmget填坑记
weixin_34326429的博客
10-22 397
1. 问题引出 最近有个项目，需要两个进程之间传递大量的数据，因此考虑采用了共享 内存机制+信号同步，两个进程，笔者和另外一程序员开发，协议都定好了，开发很顺利。 等到我们联合调试的时候，问题出现了，笔者开发的程序，共享内存初始化一直失败，那叫一个汗啊！ 代码如下： /*****************************************************************...
共享内存的创建和映射shmget()和shmat()
念愿的专栏
07-21 1万+
共享内存的实现分为两步： 1、创建共享内存，用到的函数是shmget(); 2、映射共享内存，就是把这段创建的共享内存映射到具体的进程空间去，使用的函数是：shmat(); 这样就可以使用不带缓冲的I/O读写命令对其进行操作了。 实例如下： /* * shmem.c * * Created on: 2012-7-20 * Author: liwei.cai */
Linux进程间通信源码剖析，共享内存(shmget函数详解)
热门推荐
wclin88的专栏
12-24 1万+
转至：http://blog.csdn.net/lanmanck/article/details/6092995 shmget int shmget(key_t key, size_t size, int flag); key: 标识符的规则 size:共享存储段的字节数 flag:读写的权限 返回值：成功返回共享存储的id，失败返回-1 key_t key -------
共享内存之shmget
深南大盗
12-20 564
http://linux.die.net/man/2/shmget http://linux.die.net/man/8/ipcs int shmget(key_t key, size_t size, int shmflg); 以下几种情况会创建一个新的共享内存段： 1、如果key有IPC_PRIVATE标志 2、如果没有IPC_PRIVATE标志，但是没有key对应的内存，并且sh
shmget() -- 建立共享内存
未语愁眸
04-24 2395
 #include     #include     int shmget(key_t key, size_t size, int shmflg);key_t key-----------------------------------------------    key标识共享内存的键值: 0/IPC_PRIVATE。 当key的取值为IPC_PRIVATE，则函数shmget()将创建一块新
Linux学习笔记：FIFO管道与进程通信实践
"该资源主要涉及C语言编程、数据结构、Linux应用，特别是对Linux的IO编程、进程线程编程以及进程间通信进行了深入探讨。同时，还提到了动态电压恢复器(DVR)的相关资料，包括补偿策略的研究和仿真分析。" 在给定的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值