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;
}

运行结果:

相关文章
|
1天前
|
存储 Linux C语言
Linux C/C++之IO多路复用(aio)
这篇文章介绍了Linux中IO多路复用技术epoll和异步IO技术aio的区别、执行过程、编程模型以及具体的编程实现方式。
15 1
Linux C/C++之IO多路复用(aio)
|
1天前
|
资源调度 Linux 调度
Linux C/C++之线程基础
这篇文章详细介绍了Linux下C/C++线程的基本概念、创建和管理线程的方法,以及线程同步的各种机制,并通过实例代码展示了线程同步技术的应用。
9 0
Linux C/C++之线程基础
|
1天前
|
Linux C++
Linux C/C++之IO多路复用(poll,epoll)
这篇文章详细介绍了Linux下C/C++编程中IO多路复用的两种机制:poll和epoll,包括它们的比较、编程模型、函数原型以及如何使用这些机制实现服务器端和客户端之间的多个连接。
7 0
Linux C/C++之IO多路复用(poll,epoll)
|
1天前
|
网络协议 Linux 网络性能优化
Linux C/C++之TCP / UDP通信
这篇文章详细介绍了Linux下C/C++语言实现TCP和UDP通信的方法,包括网络基础、通信模型、编程示例以及TCP和UDP的优缺点比较。
9 0
Linux C/C++之TCP / UDP通信
|
1天前
|
消息中间件 Linux API
Linux c/c++之IPC进程间通信
这篇文章详细介绍了Linux下C/C++进程间通信(IPC)的三种主要技术:共享内存、消息队列和信号量,包括它们的编程模型、API函数原型、优势与缺点,并通过示例代码展示了它们的创建、使用和管理方法。
9 0
Linux c/c++之IPC进程间通信
|
1天前
|
网络协议 安全 Linux
Linux C/C++之IO多路复用(select)
这篇文章主要介绍了TCP的三次握手和四次挥手过程,TCP与UDP的区别,以及如何使用select函数实现IO多路复用,包括服务器监听多个客户端连接和简单聊天室场景的应用示例。
17 0
|
1天前
|
监控 安全 网络协议
|
3天前
|
应用服务中间件 Linux nginx
Linux下操作Nginx相关命令
Linux下操作Nginx相关命令
|
4天前
|
Ubuntu 前端开发 Linux
Linux apt 命令
10月更文挑战第1天
18 4
|
4天前
|
缓存 前端开发 Linux
Linux yum 命令
10月更文挑战第1天
18 2