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

已于 2024-04-28 21:23:35 修改
阅读量895 收藏 27
点赞数 36
分类专栏： Linux系统编程 文章标签： linux
于 2024-04-18 21:13:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51647149/article/details/137652268
版权

一、进程间通信IPC(InterProcess Communication)

进程间通信的常用方式，特征：

1. 管道：简单

2. 信号：开销小

3. 共享存储映射(mmap)：非血缘关系进程间

4. socket（本地套接字）：最稳定

二、管道

真文件：普通文件、目录文件、软链接--->需要占用磁盘空间

伪文件：字符设备文件、块设备文件、管道文件、套接字--->不占用磁盘空间，只占用内存(缓冲区)

实现原理： 内核借助环形队列机制，使用内核缓冲区实现。

特质：

1. 伪文件
2. 管道中的数据只能一次读取。
3. 数据在管道中，只能单向流动。

局限性：

1. 自己写，不能自己读。
2. 数据不可以反复读。
3. 半双工通信。
4. 血缘关系进程间可用

管道的基本用法：

int pipe(int fd[2]);

创建，并打开管道。

参数：

        fd[0]: 读端。

        fd[1]: 写端。

返回值：

        成功： 0

        失败： -1 errno

管道通信原理：

1.父进程调用了pipe()，相当于创建了一个管道并打开了读端和写端，pipefd[0]是读端，pipefd[1]是写端

2.父进程fork出一个子进程，此时子进程也掌握着父进程管道的读端和写端

3.父进程写入数据(读端关闭)，子进程读取数据(写端关闭)

pipe demo：父进程往管道里写，子进程从管道读，然后打印读取的内容到屏幕上

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

void sys_err(const char *str)
{
        perror(str);
        exit(1);
}

int main(int argc,char *argv[])
{
        int ret;
        int fd[2];
        pid_t pid;

        char *str = "hello pipe\n";
        char buf[1024];

        ret = pipe(fd);
        if (ret == -1){
        sys_err("pipe error");}

        pid = fork();
        if (pid > 0){
                close(fd[0]);   //父进程关闭读端
                write(fd[1],str,strlen(str));//写入数据
                sleep(1);    //让终端提示和输出不混杂在一块
                close(fd[1]);//写后关闭写端
        }else if(pid == 0){
                close(fd[1]);   //子进程关闭写端
                ret = read(fd[0],buf,sizeof(buf));//读取数据到buf中
                write(STDOUT_FILENO,buf,ret);//将buf的数据打印到屏幕上，ret是字节数
                close(fd[0]);//关闭读端
        }

        return 0;
}

要是不想让终端提示和输出混杂在一起，就在父进程写入内容之后sleep一秒钟

管道的读写行为：

读管道：

1. 管道有数据，read返回实际读到的字节数。
2. 管道无数据：
        1）无写端，read返回0 （类似读到文件尾）
        2）有写端，read阻塞等待。

写管道：

1. 无读端(读端全关闭)， 进程异常终止（SIGPIPE导致的）
2. 有读端：
        1） 管道已满， 阻塞等待
        2） 管道未满， 返回写出的字节个数。

练习：使用管道实现父子进程间通信，完成：ls | wc –l。假定父进程实现wc，子进程实现ls

要求：(要用到 pipe dup2 exec)

1. 假定父进程实现wc，子进程实现ls

2. ls命令正常会将结果集写到stdout，但现在会写入管道写端

3. wc -l命令正常应该从stdin读取数据，但此时会从管道的读端读。

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

void sys_err(const char *str)
{
        perror(str); 
        exit(1);
}

int main(int argc,char *argv[])
{
        int fd[2];
        int ret;
        pid_t pid;

        ret =  pipe(fd);    //父进程先创建一个管道,持有管道的读端和写端
        if (ret == -1){
                sys_err("pipe error");
        }

        pid = fork();    //子进程同样持有管道的读和写端 
        if (pid == -1){
                sys_err("fork error");
        }else if (pid > 0){      // 父进程读,关闭写端
                close(fd[1]);
                dup2(fd[0],STDIN_FILENO);     //重定向 stdin到管道的 读端 
                execlp("wc","wc","-l",NULL);    // 执行 wc -l 程序  
                sys_err("execlp wc error");         
        }else if(pid == 0){
                close(fd[0]);
                dup2(fd[1],STDOUT_FILENO);    //重定向stdout到管道写端 
                execlp("ls","ls",NULL);    //子进程执行ls命令
                sys_err("execlp ls error");   
        }
        
        return 0;
}

兄弟间进程通信：

使用管道实现兄弟进程间通信。 兄：ls  弟： wc -l  父：等待回收子进程。 

要求，使用“循环创建N个子进程”模型创建兄弟进程，使用循环因子i标示。注意管道读写行为

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

void sys_err(const char *str)
{
        perror(str); 
        exit(1);
}

int main(int argc,char *argv[])
{
        int fd[2];
        int ret,i;
        pid_t pid;

        ret =  pipe(fd);
        if (ret == -1){
            
                sys_err("pipe error");
        }

        for (i = 0;i < 2;i++) // 表达式2 出口,仅限父进程使用  
        {
                pid = fork();
                if (pid == -1 )
                {
                        sys_err("fork error");
                }
                if (pid == 0) // 子进程,出口
                        break;
        }

        if (i == 2)  // 父进程 . 不参与管道使用.   
        {
                close(fd[0]);// 关闭管道的 读端/写端
                close(fd[1]);
                wait(NULL); // 回收子进程  
                wait(NULL);
        }

        else if (i == 0)//兄
        {
                close(fd[0]);
                dup2(fd[1],STDOUT_FILENO);// 重定向stdout  
                execlp("ls","ls",NULL);
                sys_err("execlp ls error");     
        }
        else if(i == 1)//弟弟  
        {
                close(fd[1]);
                dup2(fd[0],STDIN_FILENO);// 重定向 stdin 
                execlp("wc","wc","-l",NULL);
                sys_err("execlp wc error");     
        }
        
        return 0;
}

注意：父进程不使用管道，所以一定要关闭父进程的管道，保证数据单向流动

允许一个pipe有一个写端多个读端        也允许一个pipe有多个写端一个读端 

管道缓冲区大小：

可以使用ulimit –a 命令来查看当前系统中创建管道文件所对应的内核缓冲区大小,通常为：

pipe size            (512 bytes, -p) 8

管道pipe的优缺点： 

优点：

        简单，相比信号，套接字实现进程通信，简单很多

缺点：

        1. 只能单向通信，双向通信需建立两个管道

        2. 只能用于有血缘关系的进程间通信。该问题后来使用fifo命名管道解决。

三、FIFO

FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于“有血缘关系”的进程间，但通过FIFO，没有血缘关系的进程也能交换数据。fifo操作起来像文件

fifo原理图： 

创建方式：

  1. 命令：mkfifo 管道名
  2. 库函数：int mkfifo(const char *pathname，mode_t mode)；成功0，失败-1
  3. 参数解析：参数1是管道名，参数二是权限0664；

无血缘关系进程间通信：

读端，open fifo O_RDONLY

写端，open fifo O_WRONLY

利用mkfifo函数创建一个FIFO： 

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

int sys_err(const char *str)
{
        perror(str);
        exit(1);
}

int main(int argc,char *argv[])
{
        int ret = mkfifo("mytestfifo",0664);
        if(ret == -1)
        {
                sys_err("mkfifo error");
        }

        return 0;
}

fifo实现非血缘关系进程间通信：

非血缘关系进程，一个写fifo，一个读fifo，操作起来就像文件一样的：

writefifo.c

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

int main(int argc, char *argv[])
{
    int fd,i;
    char buf[4096];

    if(argc < 2)
    {
        printf("Enter like this: ./a.out fifoname\n");
        return -1;
    }

    fd = open(argv[1],O_WRONLY);//打开管道文件
    if(fd < 0)
    {
        perror("open");
        exit(-1);
    }

    i = 0;
    while(1)
    {
        sprintf(buf,"hello %d\n",i++);

        write(fd,buf,strlen(buf));//向管道写入数据
        sleep(1);
    }
    close(fd);

    return 0;
}

readfifo.c

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

int main(int argc,char *argv[])
{
    int fd,i;
    char buf[4096];

    if(argc < 2)
    {
        printf("./a.out fifonema\n");
        return -1;
    }
    //int fd = mkfifo("tetsfifo",0664);
    //open(fd,...);

    fd = open(argv[1],O_RDONLY);//打开管道文件
    if(fd<0)
    {
        perror("open");
        exit(-1);
       }

    while(1)
    {
        int len = read(fd,buf,sizeof(buf));//从管道的读端读取数据
        write(STDOUT_FILENO,buf,len);
        sleep(1);//多个读端时应增加睡眠秒数，放大效果
    }

    close(fd);

    return 0;
}

四、文件用于进程间通信(有没有血缘关系都行)

打开的文件是内核中的一块缓冲区。多个无血缘关系的进程，可以同时访问该文件。

  • 只是有血缘关系的进程对于同一个文件，使用的同一个文件描述符，
  • 没有血缘关系的进程，对同一个文件使用的文件描述符可能不同。
  • 这些都不是问题，打开的是同一个文件就行。

文件实现进程间通信原理图：

菜就多练wwww
关注
  • 36
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《Linux系统编程、网络编程》第7章 进程间通信（本机IPC）
06-12
课程内容：为什么需要进程通信、为什么进程空间是独立的、学习本章有什么意义、无名管道、有名管道、消息队列、共享内存、信号量。
Linux系统编程第05期：进程间通信
06-14
本视频教程为《Linux系统编程》第05期，本期课程将会带领大家学习Linux下将近15种进程间通信IPC工具的使用，了解它们的通信机制、编程实例、使用场景、内核中的实现以及各自的优缺点。 本课程会提供PDF版本的PPT课件...
Linux系统编程 --进程间通信 -共享内存
qq_45313714的博客
07-05 1171
进程间通信--共享内存共享内存概念共享内存的本质。共享内存的描述与组织 共享内存概念 共享内存区是最快的IPC（进程间通信）形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。 与管道区别: 1.管道的本质是一个文件，其进程间通信依赖I/O进行操作。而共享内存本质是多个进程共享一份内存，通过读写端不同来达到进程通信的目的。 2.管道在创建默认情况下读端为阻塞模式，而共享内存不会这样。 共享内存的本质。 共享内存的
Linux系统编程系列之进程间通信-IPC对象
AABond的博客
09-30 121
Linux系统编程系列之进程间通信-IPC对象，IPC对象的简单介绍和使用
Linux进阶-进程间通信（ipc）
weixin_47077788的博客
11-30 1557
进程间通信：数据传输、资源共享、事件通知、进程控制。
linux系统编程-进程或线程间通信机制
weixin_40555950的博客
01-16 3350
1、通信机制分类 linux进程或线程间通信机制主要分为三类： 通信：这些工具关注进程之间的数据交换。 同步：这些进程关注进程和线程操作之间的同步。 信号：在特定场景下可以将信号作为一种同步技术，信号还可以作为一种通信技术。 根据上图总结一下： 用于通信的主要有：管道和FIFO、消息队列(POSIX和SYSTEM V)、共享内存(POSIX和SYSTEM V)、内存映射、socket(数据报和流)、伪终端。 用于同步的主要有: 信号量、互斥量、条件变量等。其实又可以将互斥量，读写锁，自旋锁这一类用于保护临
[Linux]----进程间通信之管道通信
拾至名瑰的博客
11-19 1705
首先我基于通信背景来带大家了解进程间通讯！！！进程是具有独立性的！—>进程间想交互数据数据，成本会非常高！—>如果我们多进程需要协同处理一件事情我们要明确一个点，进程独立了，不是彻底独立，有时候，我们需要双方能够进行一定程度的信息交互。正文开始！管道只能用来进行具有血缘关系的进程之间，进行进程间通信。常用于父子通信管道只能单向通信(内核的实现决定)—半双工的一种特殊情况管道自带同步机制(pipe满，writer等，pipe空，reader等)—自带访问控制管道是面向字节流的。
进程间通信（IPC）介绍
02-24
进程间通信（IPC，InterProcessCommunication）是指在不同进程之间传播或交换信息。其中Socket和Streams支持不同主机上的两个进程IPC。以Linux中的C语言编程为例。管道，通常指无名管道，是UNIX系统IPC最古老的形式...
项目-银行账户管理系统（linux C编程和 消息队列实现IPC编程）.rar
09-01
客户端：提供一个界面供用户选择，当用户选择具体的业务操作之后，客户端将用户的选择信息发送给服务器进行处理，客户端等待服务器的结果，并且显示给客户。 服务器：接收客户端发来的用户选择信息进行处理，需要...
linux-journal日志文件特别大怎么办，journal日志文件学习
最新发布
你是我的天晴
04-28 169
今天发现磁盘容量不多了，就去清理磁盘，发现这个文件特别大：journal，特此来学习下。
Linux｜Awk 变量、数字表达式和赋值运算符
冷冻工厂
04-25 589
同样，数字 22 被赋予了变量 port_no，还可以把一个变量的值赋给另一个变量，就像最后一个例子中，将变量 computer_name 的值赋给了变量 server。例如，假设有一个名为 names.txt 的文件，该文件列出了一个应用程序的用户的名单，包括他们的名、姓和性别。要理解在 Awk 中数值表达式的运用，来看下面的例子，这个例子中用到了一个名为 domains.txt 的文件，这个文件列出了 Tecmint 所持有的所有域名。接下来，将探讨 Awk 的最后一个特性——赋值运算符。
Linux 学习之路 -- 进程篇 -- 进程控制
2302_79538079的博客
04-24 1163
进程控制的简单介绍
Linux：浏览器访问网站的基本流程（优先级从先到后）
fox_kang的博客
04-28 654
浏览器访问网站的基本流程（优先级从先到后） 首先查找浏览器是否存在该网站的访问缓存 其次查找本机的域名解析服务器 windows：C:\Windows\System32\drivers\etc\hosts Linux：/etc/hosts 使用外部的域名解析服务器解析（例如：114.114.114.114） 第一步：浏览器使用域名访问www.bilibili.com.网站 第二步：首先去访问根域名解析服务器查询，根服务器返回.com域名解析服务器地址==（这里的根域名解析服务器不会直接给出域名对应的
linux kernel内存泄漏检测工具之kmemleak
yanghao23的专栏
04-27 1058
3.1 原理简介kmemleak实现方法是一个插桩加扫描过程, 它提供一个kmemleak_alloc桩函数，这个函数会在内核slab、vmalloc、alloc_bootmem、pcpu_alloc等函数分配接口中被调用，每次调用时该函数均会创建一个kmemleak object记录分配内存的相关信息比如内存地址，大小，调用栈等，并将这个object加入到一个rbtree里面;当内核释放内存时，也会调用kmemleak_free删除对应object。
linux 编译binutil 遇到问题
123
04-26 208
linux 编译binutil
Linux 进程概念和状态
2301_77529683的博客
04-25 1093
我们在使用计算机本质上都是对数据进行处理，将数据输入到计算机，计算机在输出到一些设备上让我们看到。计算机在处理这些数据上都基本遵循着冯诺依曼体系。输入设备：键盘、鼠标、磁盘、网卡、话筒...存储器：内存中央处理器：cpu输出设备：显示器、声卡、磁盘、网卡...这个过程就是对数据的流动加工，先将数据输入到输入设备中，输入设备再拷贝到存储器上，存储器将数据给运算器来进行基本运算处理数据，再把加工后的数据返给存储器，由存储器给输出设备。整个过程都是由控制器来控制的。
linux 信号
l2894的博客
04-27 753
设定闹钟是再OS内部，OS内可能有很多进程使用闹钟，所以OS要管理所有的闹钟，先描述，再组织，所以内核中一定要有描述闹钟属性的结构体，并用特定的数据结构组织起来，这里可以使用小根堆来对闹钟进行管理。)，并保存在指定寄存器中，当中断发生时，CPU会暂停当前正在执行的程序，并保存当前进程的上下文数据，然后查找中断向量表，找到与中断号对应的处理函数的地址，回调方法。同时CPU有很多针脚，和外设物理连接，每个针脚有自己的编号，键盘按下按键会给特定的针脚发送高电平，触发硬件中断，CPU会识别到针脚的编号(
[Linux_IMX6ULL驱动开发]-设备树简述
levi的博客
04-24 946
这个属性有一点重要的作用是，假如我这里有两块板子，板子A以及板子B，同时使用了一个公板的设备树节点XXX.dtsi（dtsi表示可以被设备树使用#include包含），此时我的板子A不需要使用到公板的uart节点，那么我们直接在板子A的设备树中，使用&uart来引用此节点，再把状态设置为disable即可。设备树的属性如果不是自定的，那么可以直接获取，比如说reg属性，就是MEM资源，interrupts属性，就是IRQ资源，这些都是可以直接调用函数platform_get_resource获取。
Linux 抽象命名空间（Abstract Namespace）简介
日拱一卒，玉汝于成
04-25 601
与传统的 UDS 不同，抽象命名空间并不在文件系统中创建实际文件，而是仅存在于内核内存中，其名称以 localabstract: 作为前缀。在这个例子中，我们创建了一个名为 my_abstract_namespace 的抽象命名空间，并将其绑定到了刚创建的 Unix 套接字上。要在 Linux 系统中生成一个抽象命名空间，通常需要使用编程语言的套接字 API 来创建一个 Unix 域套接字，并将其绑定到一个以 localabstract: 开头的特殊路径。
Linux进程间通信(IPC)
08-21
Linux提供了多种进程间通信（IPC）的方式，以下是几种常见的IPC方法： 1. 管道（Pipe）：管道是一种半双工的通信方式，可以在父进程和子进程之间传递数据。它有两种类型：匿名管道和命名管道。 2. 共享内存（Shared Memory）：共享内存是一种高效的IPC方式，允许多个进程访问同一段物理内存。进程可以通过读写共享内存来进行通信。 3. 信号量（Semaphore）：信号量是一个计数器，用于控制多个进程对共享资源的访问。进程可以通过对信号量进行P（申请资源）和V（释放资源）操作来实现进程间的同步与互斥。 4. 消息队列（Message Queue）：消息队列是一种存放在内核中的消息链表，用于进程间的异步通信。发送方将消息放入队列，接收方从队列中读取消息。 5. 信号（Signal）：信号是一种异步的通知机制，用于向进程发送某个事件发生的信号。进程可以通过注册信号处理函数来捕捉和处理信号。 6. 套接字（Socket）：套接字是一种网络编程接口，不仅可以在本地进程间通信，还可以在网络中的不同主机之间通信。 以上是常见的几种Linux IPC方法，每种方法都有其适用的场景和特点，开发者可以根据实际需求选择适合的IPC方式来进行进程间通信。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值