Linux c/c++进程间通信(1)

简介: 这篇文章介绍了Linux下C/C++进程间通信的几种方式,包括普通文件、文件映射虚拟内存、管道通信(FIFO),并提供了示例代码和标准输入输出设备的应用。

1. 进程间通信的概念

进程间通信是指不同的进程之间进行信息的传递

    1. 同一主机上的进程通信

            父子进程之间

            非父子进程之间

    2.不同主机上的进程通信(网络通信)

2. 普通文件通信

  1. 父子进程之间可以直接通过文件描述符号(fd)直接进行通信

    **进程之间通过文件通信的模型:**        ![](https://i-blog.csdnimg.cn/blog_migrate/3356fd49c3e7606a216da7b4af5213ba.png)
    

    示例: 父进程写文件,子进程读取文件

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
//父进程写文件    子进程读文件
int main(){
    int fd = open("a.dat",O_RDWR | O_CREAT,0666);
    if(-1 == fd){
        printf("文件创建失败:%m\n"),exit(-1);
    }else{
        printf("文件创建成功!\n");
    }
    close(fd);

    if(fork()){
        //父进程写文件
        int n = 0; 
        while(1){
            int fd = open("a.dat",O_WRONLY);
            if(-1 == fd)
                printf("父: 文件打开失败:%m\n"),exit(-1);
            else
                printf("父: 文件打开成功!\n");
            write(fd,&n,4);
            close(fd);
            sleep(1);
            n+=2;
        }
    }else{
        //子进程读文件
        int m;
        while(1){
            int fd = open("a.dat",O_RDONLY);
            if(-1 == fd)
                printf("子: 文件打开失败:%m\n"),exit(-1);
            else
                printf("子: 文件打开成功!\n");
            sleep(1);
            read(fd,&m,4);
            printf(">> %d\n",m);
            close(fd);
        }
    }

    return 0;
}

运行结果:

  1. 非父子进程之间就只能通过具体的文件来进行通信

3. 文件映射虚拟内存通信

经常用于父子进程之间的通信

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
//子进程控制父进程循环的暂停与否(通过文件映射虚拟内存的方式实现)
int main(){
    //1. 打开文件
    int fd = open("mmap.dat",O_CREAT|O_RDWR,0666);
    if(-1 == fd) printf("文件创建失败:%m\n"),exit(-1);
    printf("文件创建成功!\n");
    //2. 修改文件大小
    ftruncate(fd,4);
    //3. 关联映射
    int* p = (int*)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if((int*)-1 == p) printf("mmap fail:%m\n"),exit(-1),close(fd);
    printf("mmap sucess!\n");
    *p = 0;
    //4. 使用映射
    if(fork()){
        //父进程
        int n = 0;
        while(1){
            while(*p);
            printf("父进程 >> *p == %d\n",*p);
            printf("父进程 >> %d\n",++n);
            sleep(1);
        }
    }else{
        //子进程
        char ch;
        int n = 0;
        while(1){
            read(0,&ch,1);
            if(ch == ' ')
                n++;

            if(n%2 == 1)
                *p = 1;   //暂停
            else
                *p = 0;   //继续
            printf("子进程: n: %d  *p (%d) 空格被按下!\n",n,*p);
        }
    }
    //5.卸载映射
    munmap(p,4);
    //6.关闭文件
    close(fd);

    return 0;
}

运行结果:

4. 管道通信(first in first out FIFO)

4.1 父子进程之间

    父子进程之间通过**匿名管道**进行通信

    使用**匿名管道**进行通信的步骤:

            1. 创建文件描述符号   **int  fds\[2\];**

            2. 将文件描述符号(fd)变成管道  **pipe**

            3. 使用管道

            4. 关闭文件描述符(**fd**)

示例:

    使用匿名管道  父进程循环等待用户输入并写入管道  子进程循环读取管道内容并输出
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
//使用匿名管道  父进程循环等待用户输入并写入管道  子进程循环读取管道内容并输出
int main(){
//1. 创建文件描述符号   int  fds[2];   fds[0] 读    fds[1] 写
    int fds[2]; 
//2. 将文件描述符号(fd)变成管道  pipe
    int ret = pipe(fds);
    if(-1 == ret) printf("创建管道失败:%m\n"),exit(-1);
    printf("创建管道成功!\n");
//3. 使用管道
    if(fork()){
        char wbuff[1024] = {0};
        while(1){
            scanf("%s",wbuff);
            write(fds[1],wbuff,strlen(wbuff));
            sleep(1);
        }
    }else{
        char rbuff[1024] = {0};
        while(1){
            sleep(1);
            int r = read(fds[0],rbuff,1023);
            if(r > 0){
                rbuff[r]=0;
                printf(">> %s\n",rbuff);
            }
        }
    }
//4. 关闭文件描述符(fd)
    close(fds[0]);
    close(fds[1]);

    return 0;
}

运行结果:

4.2 非父子进程之间

    非父子进程之间通过**有名管道**进行通信

    使用**有名管道**进行通信的步骤:

                  文件A                                                                    文件B

    1\. 创建管道文件 mkfifo

    2. 打开管道文件                                                           2. 打开管道文件

    3. 向管道文件写入数据                                                3\. 从管道文件读取数据

    4. 关闭管道                                                                  4. 关闭管道

    5. 删除管道文件  unlink

文件A:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
//文件A  数据写入端
int main(){
    //1.创建管道文件
    int ret = mkfifo("test.pipe",0666);
    if(-1 == ret) printf("创建管道文件失败:%m\n"),exit(-1);
    printf("创建管道文件成功!\n");

    //2.打开管道文件
    int fd = open("test.pipe",O_WRONLY,0666);
    if(-1 == fd) printf("打开管道文件失败:%m\n"),unlink("test.pipe"),exit(-1);
    printf("打开管道文件成功!\n");

    //3.向管道文件中写入数据
    int n = 0;
    char buff[1024] = {0};
    while(1){
        sprintf(buff,"Linux,学了忘得好快!%d",++n);
        write(fd,buff,strlen(buff));
        sleep(1);
    }

    //4.关闭管道
    close(fd);

    //5.删除管道文件
    unlink("test.pipe");

    return 0;
}

文件B:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
//文件B  数据读取端
int main(){
    //2. 打开管道文件
    int fd = open("test.pipe",O_RDONLY,0666);
    if(-1 == fd) printf("文件打开失败:%m\n"),unlink("test.pipe"),exit(-1);
    printf("文件打开成功!\n");
    //3. 从管道文件中读取数据
    int r = 0;
    char buff[1024]={0};
    while(1){
        r = read(fd,buff,1023);
        if(r > 0){
            buff[r] = 0;
            printf(">> %s\n",buff);
        }
    }

    //4. 关闭管道
    close(fd);

    return 0;
}

运行结果:

注:

    1. 在**共享文件夹**之中**不能创建管道文件** ![](https://i-blog.csdnimg.cn/blog_migrate/c2d9c0472af45e4e0e10ea6d43ffd12f.png)

    2. 打开管道文件的时候只有**两边一起打开**才会返回,只有一边打开会阻塞

    3. **先关闭读取端,会导致写入端进程结束**        ![](https://i-blog.csdnimg.cn/blog_migrate/6744dcc8317558c3a7833c15baf5d722.png)

    4.**先关闭写入端,读取端进程进入阻塞状态**                ![](https://i-blog.csdnimg.cn/blog_migrate/951ed8af615f844fed1f83c16bdbf2cb.png)

5. 关于标准输入设备(0)与标准输出设备(1)的使用

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

int main(){
    char buff[1024];
    int r;
    while(1){
        //使用标准输入设备输入
        //输入,向内存中输入,等于从文件读取到内存因此为read
        r = read(0,buff,1023);
        if(r > 0){
            buff[r] = 0;
            //使用标准输出设备输出
            //输出,从内存中输出,等于从内存写到文件因此为write
            write(1,buff,r);
            printf("\n");
        }
    }

    return 0;
}

运行结果:

相关文章
|
7天前
|
运维 监控 Linux
Linux操作系统的守护进程与服务管理深度剖析####
本文作为一篇技术性文章,旨在深入探讨Linux操作系统中守护进程与服务管理的机制、工具及实践策略。不同于传统的摘要概述,本文将以“守护进程的生命周期”为核心线索,串联起Linux服务管理的各个方面,从守护进程的定义与特性出发,逐步深入到Systemd的工作原理、服务单元文件编写、服务状态管理以及故障排查技巧,为读者呈现一幅Linux服务管理的全景图。 ####
|
1月前
|
缓存 监控 Linux
linux进程管理万字详解!!!
本文档介绍了Linux系统中进程管理、系统负载监控、内存监控和磁盘监控的基本概念和常用命令。主要内容包括: 1. **进程管理**: - **进程介绍**:程序与进程的关系、进程的生命周期、查看进程号和父进程号的方法。 - **进程监控命令**:`ps`、`pstree`、`pidof`、`top`、`htop`、`lsof`等命令的使用方法和案例。 - **进程管理命令**:控制信号、`kill`、`pkill`、`killall`、前台和后台运行、`screen`、`nohup`等命令的使用方法和案例。
113 4
linux进程管理万字详解!!!
|
23天前
|
存储 运维 监控
深入Linux基础:文件系统与进程管理详解
深入Linux基础:文件系统与进程管理详解
62 8
|
20天前
|
Linux
如何在 Linux 系统中查看进程占用的内存?
如何在 Linux 系统中查看进程占用的内存?
|
1月前
|
算法 Linux 定位技术
Linux内核中的进程调度算法解析####
【10月更文挑战第29天】 本文深入剖析了Linux操作系统的心脏——内核中至关重要的组成部分之一,即进程调度机制。不同于传统的摘要概述,我们将通过一段引人入胜的故事线来揭开进程调度算法的神秘面纱,展现其背后的精妙设计与复杂逻辑,让读者仿佛跟随一位虚拟的“进程侦探”,一步步探索Linux如何高效、公平地管理众多进程,确保系统资源的最优分配与利用。 ####
69 4
|
1月前
|
缓存 负载均衡 算法
Linux内核中的进程调度算法解析####
本文深入探讨了Linux操作系统核心组件之一——进程调度器,着重分析了其采用的CFS(完全公平调度器)算法。不同于传统摘要对研究背景、方法、结果和结论的概述,本文摘要将直接揭示CFS算法的核心优势及其在现代多核处理器环境下如何实现高效、公平的资源分配,同时简要提及该算法如何优化系统响应时间和吞吐量,为读者快速构建对Linux进程调度机制的认知框架。 ####
|
1月前
|
消息中间件 存储 Linux
|
2月前
|
运维 Linux
Linux查找占用的端口,并杀死进程的简单方法
通过上述步骤和命令,您能够迅速识别并根据实际情况管理Linux系统中占用特定端口的进程。为了获得更全面的服务器管理技巧和解决方案,提供了丰富的资源和专业服务,是您提升运维技能的理想选择。
53 1
|
2月前
|
Ubuntu Linux 编译器
Linux/Ubuntu下使用VS Code配置C/C++项目环境调用OpenCV
通过以上步骤,您已经成功在Ubuntu系统下的VS Code中配置了C/C++项目环境,并能够调用OpenCV库进行开发。请确保每一步都按照您的系统实际情况进行适当调整。
378 3
|
2月前
|
算法 Linux 调度
深入理解Linux操作系统的进程管理
【10月更文挑战第9天】本文将深入浅出地介绍Linux系统中的进程管理机制,包括进程的概念、状态、调度以及如何在Linux环境下进行进程控制。我们将通过直观的语言和生动的比喻,让读者轻松掌握这一核心概念。文章不仅适合初学者构建基础,也能帮助有经验的用户加深对进程管理的理解。
32 1