高编：进程间通信 IPC interprocess communicate

已于 2024-07-02 17:25:12 修改
阅读量1k 收藏 25
点赞数 19
文章标签： linux 运维 服务器
于 2024-07-02 17:18:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71751116/article/details/140118329
版权

一、进程间三大类通信

1、古老的通信方式

        无名管道  有名管道  信号

2、IPC对象通信 system v(5)    BSD     suse fedora   kernel.org

        消息队列(用的相对少，这里不讨论)
        共享内存
        信号量集(进程间做互斥与同步semaphore)

3、socket通信

        网络通信

二、管道

无名管道 ===》pipe ==》只能给有亲缘关系进程通信
有名管道 ===》fifo ==》可以给任意单机进程通信

1.管道的特性

1）管道是 半双工的工作模式
2）所有的管道都是特殊的文件不支持定位操作。lseek->> fd  fseek ->>FILE* 
3）管道是特殊文件，读写使用文件IO。fgets,fread,fgetc（标准IO，文本文件常用）
    open,read,write,close;（文件IO，一般用这个，二进制文件常用）
  

 2.无名管道使用注意事项 

1）读端存在，一直向管道中去写（写得太快），超过64k，写会阻塞。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char *argv[])
{
    int pipefd[2]={0};
    int ret = pipe(pipefd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }

    pid_t pid = fork();
    if(pid>0)
    {
        char buf[1024]={0};
        close(pipefd[0]);
        memset(buf,'a',1024);
        int i = 0 ;
        for(i=0;i<65;i++)
        {
            write(pipefd[1],buf,sizeof(buf));
            printf("i is %d\n",i);
        }
    }
    else if(0 == pid)
    {
        close(pipefd[1]);
        char buf[100]={0};
        while(1)sleep(1);
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    return 0;
}


2）写端存在，读管道，（写得慢，读得快）如果管道为空的话，读会阻塞。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char *argv[])
{  
    int pipefd[2]={0};
    int ret = pipe(pipefd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }

    pid_t pid = fork();
    if(pid>0)
    {
        char buf[]="capper";
        close(pipefd[0]);
        sleep(3);
        write(pipefd[1],buf,strlen(buf));
    }
    else if(0 == pid)
    {
        close(pipefd[1]);
        char buf[100]={0};
        read(pipefd[0],buf,sizeof(buf));
        printf("pipe %s\n",buf);
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    return 0;
}

阻塞3s后，才打印出结果


3）管道破裂，读端关闭，写管道出错，程序结束。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char *argv[])
{
    int pipefd[2]={0};
    int ret = pipe(pipefd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }

    pid_t pid = fork();
    if(pid>0)
    {
        char buf[]="hello,world";
        close(pipefd[0]);
        sleep(3);
        // 管道破裂 gdb  跟踪
        write(pipefd[1],buf,strlen(buf));
        printf("aaaa\n");
    }
    else if(0 == pid)
    {
        close(pipefd[1]);
        close(pipefd[0]);
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    return 0;
}

管道破裂，程序退出 


4）写端关闭，如果管道没有内容，读端返回0，read 0 ；

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char *argv[])
{
    int pipefd[2]={0};
    int ret = pipe(pipefd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }

    pid_t pid = fork();
    if(pid>0)
    {
        char buf[]="hello,world";
        close(pipefd[0]);
        write(pipefd[1],buf,strlen(buf));
        write(pipefd[1],buf,strlen(buf));
        close(pipefd[1]);
    }
    else if(0 == pid)
    {
        close(pipefd[1]);
            char buf[5]={0};
        while(1)
        {
            //memset(buf,0,5);
            bzero(buf,sizeof(buf));
            int rd_ret = read(pipefd[0],buf,sizeof(buf)-1);
            if(rd_ret<=0)
            {
                break;
            }
            printf("pipe %s\n",buf);
        }
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    return 0;
}

3.无名管道使用框架

创建管道 ==》读写管道 ==》关闭管道

1.无名管道 ===》管道的特例 ===>pipe函数
特性：
1.1  亲缘关系进程使用
1.2  有固定的读写端


2.3.1创建并打开管道

pipe函数
#include <unistd.h>
int pipe(int pipefd[2]);
功能：创建并打开一个无名管道
参数：pipefd[0] ==>无名管道的固定读端
           pipefd[1] ==>无名管道的固定写端
返回值：成功  0
              失败 -1；

注意事项：
无名管道的架设应该在fork之前进行。
    
无名管道的读写：===》文件IO的读写方式。
  读： read() 
  写： write() 

关闭管道： close();

练习：相当于cp的功能
    设计一个多进程程序，用无名管道完成父子进程间的任意信息：传送，包括数字、字符串等。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
int main(int argc, char *argv[])
{
    int pipefd[2]={0};
    int ret = pipe(pipefd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }

    pid_t pid = fork();
    if(pid>0)
    {
        close(pipefd[0]);
       int fd =  open("/home/linux/1.png",O_RDONLY);
       if(-1 == fd)
       {
            perror("open");
            exit(1);
       }
       while(1)
       {
            char buf[4096]={0};
            int rd_ret = read(fd,buf,sizeof(buf));
            if(rd_ret<=0)
            {
                break;
            }
            write(pipefd[1],buf,rd_ret);
       }
       close(fd);
       close(pipefd[1]);
    }
    else if(0 == pid)
    {
        close(pipefd[1]);
        int fd = open("2.png",O_WRONLY|O_CREAT|O_TRUNC,0666);
        if(-1==fd)
        {
            perror("open");
            exit(1);
        }
        while(1)
        {
            char buf[1024]={0};
            int rd_ret = read(pipefd[0],buf,sizeof(buf));
            if(rd_ret<=0)
            {
                break;
            }
            write(fd,buf,rd_ret);
        }
        close(fd);
        close(pipefd[0]);
    }
    else 
    {
        perror("fork");
        exit(1);
    }
    return 0;
}

运行结果：将1.png复制为2.png

验证如下问题：
1、父子进程是否都有fd[0] fd[1]，如果在单一进程中写fd[1]能否直接从fd[0]中读到。

        可以，写fd[1]可以从fd[0]读

2、管道的数据存储方式是什么样的数据是否一直保留？
        栈， 先进后出
        队列形式存储 读数据 会剪切取走数据 不会保留    <先进先出>

3、管道的数据容量是多少，有没有上限值。
        操作系统的建议值： 512* 8 = 4k
         man 7 pipe
        代码测试实际值：   65536byte= 64k

4、管道的同步效果如何验证？读写同步验证。
     读端关闭能不能写？ 不可以 ===>SIGPIPE 异常终止 
     写端关闭能不能读？ 可以，取决于pipe有没有内容，===>read返回值为0 不阻塞

        结论：读写端必须同时存在，才能进行管道的读写。

5、固定的读写端是否就不能互换？
     能否写fd[0] 能否读fd[1]?   不可以，是固定读写端。

4.有名管道

有名管道===》fifo ==》有文件名称的管道。文件系统中可见

框架：
    创建有名管道 ==》打开有名管道 ==》读写管道==》关闭管道  ==》卸载有名管道

2.4.1 创建：mkfifo

#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);
功能：在指定的pathname路径+名称下创建一个权限为mode的有名管道文件。
参数：pathname要创建的有名管道路径+名称
          mode  8进制文件权限//0666/0777
返回值：成功 0
              失败  -1；

2.4.2 打开有名管道 open

    注意：该函数使用的时候要注意打开方式，因为管道是半双工模式，所有打开方式直接决定当前进程的读写方式。
    一般只有如下方式：
    int fd-read = open("./fifo",O_RDONLY); ==>fd 是固定读端
    int fd-write = open("./fifo",O_WRONLY); ==>fd 是固定写端
    不能是 O_RDWR 方式打开文件
    不能有 O_CREAT 选项，因为创建管道有指定的mkfifo函数

2.4.3 有名管道的读写： 文件IO

    读： read(fd-read,buff,sizeof(buff));
    写： write(fd-write,buff,sizeof(buff));

2.4.4 关闭管道

close(fd)；

2.4.5 卸载有名管道

remove();
int unlink(const char *pathname);
功能：将指定的pathname管道文件卸载，同时从文件系统中删除。
参数： ptahtname 要卸载的有名管道 
返回值：成功  0
              失败  -1

01fifo_w.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {

        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }
    //open 会阻塞，等到另一端读段打开，解除阻塞
    int fd = open("myfifo",O_WRONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }

    char buf[256]="hello,fifo,test";
    write(fd,buf,strlen(buf));
    close(fd);

    return 0;
}

02fifo_r.c

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

int main(int argc, char *argv[])
{
    int ret = mkfifo("myfifo",0666);    
    if(-1 == ret)
    {
        //如果是管道文件已存在错误，让程序继续运行
        if(EEXIST== errno)
        {
        
        }else 
        {
            perror("mkfifo");
            exit(1);
        }
    }

    int fd = open("myfifo",O_RDONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }

    char buf[256]={0};
    read(fd,buf,sizeof(buf));
    printf("fifo %s\n",buf);
    close(fd);
    //remove("myfifo");

    return 0;
}

1、是否需要同步，以及同步的位置。
        读端关闭 是否可以写，不能写什么原因。
        写端关闭 是否可以读。

        结论：有名管道执行过程过必须有读写端同时存在。
                   如果有一端没有打开，则默认在open函数部分阻塞。

2、有名管道是否能在fork之后的亲缘关系进程中使用。
        结论： 可以在有亲缘关系的进程间使用。
        注意： 启动的次序可能会导致其中一个稍有阻塞。

3、能否手工操作有名管道实现数据的传送。
        读： cat  fifoname
        写： echo "asdfasdf" > fifoname

Yao_xiiiin.
关注
  • 19
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
进程间通信IPC(InterProcessCommunication)
02-24
内核提供的这种机制称为进程间通信（IPC，InterProcessCommunication）进程间通信模型管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道。只能用于父子进程或者兄弟进程之间(具有亲缘...
interprocess:用于Rust的多功能跨平台进程间通信工具包
05-20
进程间 用于Rust程序的进程间通信工具包。 该板条箱旨在尽可能多地显示特定于平台的功能，同时为所有平台保持统一的界面。特征实现了以下进程间通信原语： 未命名管道-匿名文件状对象，用于在一个方向上私下通信，最...
进程间通信IPC
春夜喜雨的专栏
02-17 388
进程间通信的方式有很多的，例如我们经常代码中用到或看到的：共享内存、socket通信、信号量、内存映射文件，文件，管道等。
进程间的通信IPC
l22221的博客
02-28 931
进程间的通信方式：1.管道2.信号3.消息队列4.共享内存5.信号灯6.套接字。
linux——IPC 进程间通信
m0_71703182的博客
07-03 844
在多进程操作系统中，不同的进程可能需要交换数据以完成共同的任务。：由于进程空间的独立性，一个进程无法直接读取或修改另一个进程的内存空间中的数据。这个返回值0是一个特殊的信号，它告诉读端进程，管道的写端已经被关闭，并且管道中没有更多的数据可以读取了。==>fd 是固定写端。函数从管道中读取数据，并且管道已经为空（即没有任何待读取的数据），同时写端已经被关闭，那么。1,读端存在，一直向管道中去写，超过64k，写会阻塞。2，写端是存在的，读管道，如果管道为空的话，读会阻塞（读的快，写的慢）
嵌入式学习 （Day:27 IPC --- 进程间通信)
weixin_43687188的博客
05-27 637
有名管道===》fifo ==》有文件名称的管道。写的快，读的慢，写满了，写阻塞）有名管道 ===》fifo ==》可以给任意单机进程通信 （父子，爷孙，旁系关系（非父子/爷孙，如：堂兄妹）也行）3.管道破裂，，读端关闭，写管道。（读端关闭，即没有接受方了，写的话，写端也会关闭，即写端管道破裂；无名管道 ===》pipe ==》只能给有亲缘关系进程通信 （pipe,管子，父子进程，爷孙进程可用）2，写端是存在的，读管道，如果管道为空的话，读会阻塞。（写端和读端都存在，写的慢，读的块，读阻塞）
进程间通信(1)PPT文档.pptx
11-14
进程间通信（IPC，InterProcess Communication）是操作系统中一种机制，允许不同的进程之间交换信息和协调操作。在Linux系统中，有多种实现进程间通信的方式，包括管道、FIFO（有名管道）、消息队列、信号量和共享...
简单的高级进程间通信库（SHLIPC）
04-11
总之，SHLIPC是一个为Windows平台设计的实用IPC库，它简化了多进程通信的复杂性，使开发者能更加专注于应用程序的业务逻辑。通过深入理解和使用SHLIPC，可以提升软件的可扩展性和性能，特别是在分布式系统和并发环境...
Linux：基础命令学习
最新发布
qq_55038440的博客
07-20 514
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
LINUX:懒汉单例模式线程池
W2155的博客
07-16 474
创建一个线程，就是要这个线程去完成某种任务的。池化技术就是，提前创建一批线程，有任务这一批线程就会执行。而不是有任务的时候在去创建线程。池化技术有着更高的效率，因为线程都是提前创建好的，直接执行任务。
Qmi8658a姿态传感器使用心得（2）linux
Starry的博客
07-19 940
COD 原理，CTRL9，自检（详细代码示例）
【Linux杂货铺】期末总结篇4：shell编程
聆风吟的博客
07-17 3958
本文主要分享作者本人期末复习的总结，欢迎大家借鉴浏览。
linux centos nginx 报错 client intended to send too large body: 104853014 bytes问题
qq_42250832的博客
07-17 317
这个错误通常发生在Web服务器处理HTTP请求时，当客户端尝试发送的请求体（body）大小超过了服务器配置的限制时。错误信息 “client intended to send too large body: 104853014 bytes” 表示客户端想要发送的数据量超过了100MB，这通常是由于客户端尝试上传一个非常大的文件或者提交了一个非常大的表单。增加服务器接收请求体的大小限制。这通常可以通过配置文件来实现，例如，如果你使用的是Nginx，可以修改client_max_body_size指令。
文件在Linux下为binary格式在Windows下为utf-8格式
qq_38220334的博客
07-17 334
想着是不是之前遇到的问题，有可能是文件中含有特殊字符，然后用vim命令来编辑这个文件，发现，还真是含有一个特殊字符，然后将它删除掉，文件就变成utf-8格式的文件了。在Windows下和Mac下都是没有问题的，在华为云服务器上也是没问题的（操作系统不是centos），但是在自己搭建的Linux服务器（centos）上是有问题的。用shell或者Python脚本去将这个文件转为utf-8格式的，但是都失败了。
Linux 注意事项
m0_74012211的博客
07-19 457
Linux 与 Windows 是两个相互独立的操作系统，两者有较大差距
Linux（CentOS7）部署PHP-7.2.17源码包
thetender的博客
07-18 1032
LAMP系统安装 通过PHP的源码包部署PHP-7.2.17版本
【Linux】文件管理常用命令【超详细】
2301_82023330的博客
07-16 727
这篇博客介绍了Linux系统中的常用文件管理命令，包括`ls`、`cd`、`cp`、`mv`、`rm`和`mkdir`等。通过这些命令，用户可以高效地浏览目录、复制和移动文件、删除文件以及创建新目录。文章详细讲解了每个命令的基本用法和常见选项，并通过实例演示了这些命令在实际操作中的应用，帮助读者掌握文件管理的基本技能，提升Linux系统的使用效率。
【Linux】基本指令
2302_79031646的博客
07-16 602
Linux基本指令
"深入探讨进程间通信IPC的类型及特点
套接口提供了面向连接和面向消息的通信方式，适用于网络编程和跨主机进程通信的场景。 综上所述，不同的IPC机制在进程间通信中扮演着不同的角色，各具特点和适用场景。通过选择合适的IPC机制，可以实现进程间的高效...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值