linux进程通信

最新推荐文章于 2024-11-02 14:00:54 发布
最新推荐文章于 2024-11-02 14:00:54 发布
阅读量572 收藏
点赞数
分类专栏： linux进程 文章标签： linux 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaopengvv/article/details/121318924
版权
本文详细介绍了IPC（进程间通信）的各种方式，包括管道（pipe）、有名管道（fifo）、mmap文件映射、本地socket、信号量和共享内存，以及它们的优缺点和使用案例。重点演示了管道的双向通信解决方案和mmap在父子进程间共享内存的应用。
摘要由CSDN通过智能技术生成

IPC (interProcess Communication) 进程间通信，通过内核提供的缓冲区，进行数据的交换机制。

IPC通信的几种方式：

  • pipe 管道 最简单
  • fifo 有名管道
  • mmap 文件映射共享IO， 速度最快
  • 本地socket最稳定
  • 信号 携带的信号量最小
  • 共享内存
  • 消息队列

1. 管道pipe

  • 管道通信优劣：
    优点：简单，相比信号和套接字实现进程通信简单很多
    缺点：1. 只能单向通信（半双工），双向通信需要建立两个管道？2. 只能用于父子、兄弟（有共同祖先）进程之间的通信。该问题可以有FIFO有名管道解决。

  • man pipe 查看函数

    #include <unistd.h>
int pipe(int pipefd[2]);

#define _GNU_SOURCE             /* See feature_test_macros(7) */
#include <fcntl.h>              /* Obtain O_* constant definitions */
#include <unistd.h>
int pipe2(int pipefd[2], int flags);

  • 进程通信demo

    #include <stdio.h>
#include <unistd.h>
int main()
{
    printf("Begin ..\n");
    int fd[2];
    pipe(fd); // 先创建管道，再创建子进程
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        write(fd[1], "hello", 5);
    } else if(pid > 0) {
        // 父进程
        char buff[12] = {0};
        int ret = read(fd[0], buff, sizeof(buff)); // 阻塞等待
        if(ret > 0) {
            write(STDOUT_FILENO, buff, ret);
        }
    }
    printf("End ...\n");
    return 0;
}

  • 读管道
    写端全部关闭 --read读到0，相当于读到文件末尾
    写端没有完全关闭，有数据 read 读到数据，没有数据 read 阻塞 fcntl函数可以更改非阻塞
    写端全部关闭demo

    #include <stdio.h>
#include <unistd.h>
int main()
{
    printf("Begin ..\n");
    int fd[2];
    pipe(fd); // 先创建管道，再创建子进程
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        sleep(3);
        close(fd[0]); // 关闭读端
        write(fd[1], "hello", 5);
        close(fd[1]); // 关闭写端
        sleep(10);
    } else if(pid > 0) {
        // 父进程
        char buff[12] = {0};
        close(fd[1]); // 关闭写端
        while (1) {
            int ret = read(fd[0], buff, sizeof(buff)); // 阻塞等待
            if (ret == 0) { // 如果写端全部关闭（所有写端），read会读到0
                printf("\n read over! \n");
                break;
            }
            if(ret > 0) {
                write(STDOUT_FILENO, buff, ret);
            }
        }
    }
    printf("End ...\n");
    return 0;
}

    输出：

    Begin ..
hello
 read over! 
End ...

  • 写管道
    读端全部关闭 产生一个信号SIGPIPE，程序异常终止
    读端未全部关闭，管道已满 write 阻塞，管道未满 write 正常写入

    读端全部关闭程序

    #include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
    printf("Begin ..\n");
    int fd[2];
    pipe(fd); // 先创建管道，再创建子进程
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        sleep(3);
        close(fd[0]); // 关闭读端
        write(fd[1], "hello", 5);
        close(fd[1]); // 关闭写端
        sleep(10);
    } else if(pid > 0) {
        // 父进程
        char buff[12] = {0};
        close(fd[1]); // 关闭写端
        close(fd[0]); // 关闭读端
        int status;
        wait(&status);
        if (WIFSIGNALED(status)) {
            printf("killed by %d\n", WTERMSIG(status));
        }
        while (1) {
            int ret = read(fd[0], buff, sizeof(buff)); // 阻塞等待
            if (ret == 0) {
                printf("\n read over! \n");
                break;
            }
            if(ret > 0) {
                write(STDOUT_FILENO, buff, ret);
            }
        }
    }
    printf("End ...\n");
    return 0;
}

    输出结果

    Begin ..
killed by 13

    补充： ulimit -a 查看所有系统资源的上限

2. FIFO有名管道

区分与pipe，pipe只能再有血缘关系的进程之间通信，而fifo可以实现非血缘关系的进程之间的通信。
FIFO是linux系统基础文件的一种，但是，FIFO文件在磁盘上没有数据块，仅仅用来表示内核中一条通道。各个进程可以打开这个文件进行read/write，实际上是在读写内核通道，这样就实现了进程间通信。

  • 创建一个管道伪文件
    mkfifo myfifo 创建命令
    也可以使用函数int mkfifo(cosnt char* pathname, mode_t mode);

  • 内核会针对fifo文件开辟一个缓冲区，操作fifo文件，实现进程间的通信。（实际上就是文件读写）

  • FIFO写数据demo

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

int main(int argc, char *argv[])
{
    if (argc != 2) {
        printf("./a.out fifoname\n");
    }
    // 当前目录有一个myfifo文件
    // 打开fifo文件
    int fd = open(argv[1], O_WRONLY);
    // 写数据
    char buf[256];
    int num = 1;
    while (num < 100) {
        memset(buf, 0x00, size(buf));
        sprintf(buf, "xiaoming%02d", num++);
        write(fd, buf, strlen(buf));
        sleep(1);
	}
    close(fd);
    return 0;
}

    FIFO读数据demo

    int main(int argc, char* argv[])
{
    if (argc != 2) {
        printf("./a.out fifoname\n");
    }
    // 当前目录有一个myfifo文件
    // 打开fifo文件
    int fd = open(argv[1], O_WRONLY);
    char buf[256];
    int ret;
    while (1){
        // 循环读
        memset(buf, 0x00, sizeof(buf));
        ret = read(fd, buf, sizeof(buf));
        if (ret < 0) {
            printf("read:%s", buf);
        }
    }
    close(fd);
    return 0;
}

    注：打开fifo文件的时候，read会阻塞等待write端open，write端也会阻塞等待另一端打开。

3. mmap

  • 函数
#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags,
           int fd, off_t offset);
int munmap(void *addr, size_t length);

创建映射区 mmap 函数参数：

  • addr： 传 NULL
  • length： 映射区长度
  • prot：
    PROT_READ 可读
    PROT_WRITE 可写
  • flags：
    MAP_SHARED 共享的（进程间通信必须是共享的）
    MAP_PRIVATE 私有的
  • fd 文件描述符，open打开一个文件
  • offset 偏移量
  • 返回值
    成功， 返回可用的内存首地址
    失败， 返回 MAP_FAILED

释放映射区 munmap函数：

  • addr 传 mmap返回值
  • length mmap创建的长度
  • 返回值
    成功返回 0
    失败返回 -1

创建映射区程序demo

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>
int main()
{
    int fd = open("mem.txt", O_RDWR);
    // 创建映射区
    char *mem = (char *)mmap(NULL, 8, PROT_READ|PROT_WRITE, MAP_SHARED, 0);
    if (mem == MAP_FAILED) {
        perror("mmap err");
        return -1;
    }
    strcpy(mem, "hello");

    //释放mmap
    munmap(mem, 8);
    close(fd);
    return 0;
}

  • mmap 9问
    在这里插入图片描述

  • 使用mmap实现父子进程之间通信

    #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/mman.h>
int main()
{
    int fd = open("mem.txt", O_RDWR);
    // 创建映射区
    char *mem = (char *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (mem == MAP_FAILED) {
        perror("mmap err");
        return -1;
    }
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        *mem = 'a';
        printf("child, *mem = %s\n", mem);
        sleep(3); // 等待父进程修改
        printf("child, *mem = %s\n", mem);
    } else if (pid > 0) {
        // 父进程
        sleep(1); // 等待子进程修改
        printf("parent, *mem = %s\n", mem);
        *mem = 'b';
        printf("parent, *mem = %s\n", mem);
        wait(NULL);
    }

    //释放mmap
    munmap(mem, 8);
    close(fd);
    return 0;
}
    • 输出结果
    child, *mem = a
parent, *mem = a
parent, *mem = b
child, *mem = b

结论：父子进程共享，1. 打开文件； 2. mmap建立映射区（但是必须使用）

  • 匿名映射
    通过使用mmap发现，使用映射区完成文件的读写非常方便，父子进程间通信也比较容易。缺陷是，每次创建一个映射区必须依赖一个文件才能实现。通过创建一个映射区要open一个temp文件，最后必须close，比较麻烦。使用匿名映射无需依赖一个文件即可创建一个映射区，需要借助标志位参数flags来指定。
    在这里插入图片描述

  • 匿名映射程序demo

    #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/mman.h>
int main()
{
    // 创建映射区
    char *mem = (char *)mmap(NULL, 4, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
    if (mem == MAP_FAILED) {
        perror("mmap err");
        return -1;
    }
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        *mem = 'a';
        printf("child, mem = %s\n", mem);
        sleep(3); // 等待父进程修改
        printf("child, mem = %s\n", mem);
    } else if (pid > 0) {
        // 父进程
        sleep(1); // 等待子进程修改
        printf("parent, mem = %s\n", mem);
        *mem = 'b';
        printf("parent, mem = %s\n", mem);
        wait(NULL);
    }

    //释放mmap
    munmap(mem, 8);
    return 0;
}

  • 使用mmap实现无血缘关系的进程通信
    写端demo

    #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
struct Student{
    int id;
    char name[20];
};


int main(int argc, char *argv[])
{
    if (argc != 2) {
        printf( "./main filename\n");
        return -1;
    }
    // 1. 打开文件
    int fd = open(argv[1], O_RDWR | O_CREAT | O_TRUNC, 0666);
    int len = sizeof(Student);
    // ftruncate 修改文件大小为 len
    ftruncate(fd, len);

    // 2. mmap
    Student *stu = (Student *)mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (stu == MAP_FAILED) {
        perror("mmap error");
    }

    // 3. 修改内存数据
    unsigned int num = 1;
    while (1) {
        stu->id = num;
        sprintf(stu->name, "xiaoming-%03d", num++);
        sleep(1);
    }

    // 4. 释放映射区和关闭文件描述符
    munmap(stu, len);
    close(fd);

    return 0;
}

    读端demo

    #include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
struct Student{
    int id;
    char name[20];
};


int main(int args, char* argv[])
{
    int fd = open(argv[1], O_RDWR);
    int len = sizeof(Student);
    Student *stu = (Student *)mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (stu == MAP_FAILED) {
        perror("mmap err");
    }
    while(1) {
        printf("id = %d, name = %s\n", stu->id, stu->name);
        sleep(1);
    }

    munmap(stu, len);
    close(fd);
    return 0;
}
知识搬运工Mr.zh
关注
专栏目录
【并发编程四】windows进程通信和Linux进程通信
junxuezheng的博客
11-12 1833
原本写完上一篇[【并发编程三】C++进程通信（管道pipe)],就准备写消息队列的c++demo了，但是真正查找资料才发现网上都是linux下的消息队列的c++demo，就没有windows下的消息队列的进程通信的demwindows没有信号这个概念，但是会提供类似功能的api,比如，杀死进程：linux下的kill信号，windows下提供TerminateProcess的api接口。
进程通讯fifo
paul123456789io的博客
10-18 310
//转自陈颢文(老师)的blog fifo1.c #include #include #include #include #include #include #include //./a.out fifoname int main(int argc, const char *argv[]) { int fd = 0; if(argc < 2) {
linux fifo通信,linux 进程间通信 之fifo
weixin_35637837的博客
05-14 1014
上一篇博客已经介绍了一种进程间通信的方式，但是那只是针对于有血缘关系的进程，即父子进程间的通信，那对于没有血缘关系的进程，那要怎么通信呢？这就要创建一个有名管道，来解决无血缘关系的进程通信, fifo:book@ubuntu:~$ mkfifo xwpbook@ubuntu:~$ ls -l myfifoprw-rw-r-- book book Feb myfifomkfifo 既有命...
Linux进程通信
qq_57611608的博客
02-27 2488
笔者在学习linux的过程中对linux进程通信进行记录学习。现在在 Linux 中使用较多的进程间通信方式主要有以下几种。 （1）管道（Pipe）及有名管道（named pipe）：管道可用于具有亲缘关系进程间的通信， 有名管道，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。 （2）信号（Signal）：信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信 方式，用于通知接受进程有某事件发生，一个进程收到一个信号与处理器收到一个中断请求 效果上可以说是一样的。 （3）消息队列：消息
Linux进程通信——信号量
2301_78772787的博客
11-26 1366
计数器。
linux进程通信方式及其详细实例
qq_46017342的博客
03-09 474
linux进程通信方式及其详细实例，超级详细
Linux进程通信之进程信号
m0_60010936的博客
12-06 980
的
linux 进程通信实验报告,Linux实验报告
weixin_30962449的博客
04-29 1488
课程编号：B080103040Linux操作系统 实验报告姓 名 班 级 实验名称 邵春晓 软工1201 学 号 指 导 教 师 Linux操作系统实验 20124670 石 凯 开 设 学 期 实 验 时 间 2014-2015第一学期 第11周——第18周 评定人签字 评 定 日 期 石 凯 评 定 成 绩 东北大学软件学院实验一 熟悉...
进程通信实验Linux,Linux进程通信实验报告
weixin_39594457的博客
05-03 990
《Linux进程通信实验报告》由会员分享，可在线阅读，更多相关《Linux进程通信实验报告(5页珍藏版)》请在人人文库网上搜索。1、Linux进程通信实验报告一、 实验目的和要求1. 进一步了解对进程控制的系统调用方法。2. 通过进程通信设计达到了解UNIX或Linux系统中进程通信的基本原理。二、 实验内容和原理1. 实验编程，编写程序实现进程的管道通信(设定程序名为pipe.c)。使用系统调用...
Linux实验三进程通信,Linux进程通信实验（管道通信）
weixin_29677553的博客
04-28 1111
上学期接触了linux系统，刚好操作系统课程的实验内容也都是要求在linux下完成，几个实验中个人认为对两个进程通信实验了解学习的比较好，所以这一篇和下一篇记录一下两个实验过程中的学习收获和实验成果。实验要求：由父进程创建一个管道和三个子进程，实现子进程和父进程间的通信(三个子进程发送后父进程接收)并测试管道大小以及进程对管道的实际写入字节数。#include#include#include#in...
实验 Linux进程通信的参考答案
07-05
实验 Linux 进程通信的参考答案 Linux 进程通信是指在操作系统中，多个进程之间进行数据交换和同步的机制。在 Linux 中，进程通信可以通过信号、管道和共享内存等方式实现。 一、信号机制 在 Linux 中，信号是一...
Linux进程通信（IPC）方式简介
01-20
进程间通信的目的 数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几兆字节之间。共享数据：多个进程想要操作共享数据，一个进程对...linux下进程间通信的几种主要方式： （1）管道（pip
Linux 进程通信
04-18
【Linux 进程通信】 在Linux操作系统中，进程间通信（IPC：InterProcess Communication）是实现不同进程之间数据交换和协调工作的重要机制。虽然通过共享文件进行通信是一种常见的方式，但在讨论IPC时，通常指的是...
Linux特种文件系统--tmpfs文件系统
刘元林的博客
10-29 985
tmpfs类似于RamDisk（只能使用物理内存），使用虚拟内存（简称VM）子系统的页面存储文件。tmpfs完全依赖VM，遵循子系统的整体调度策略。说白了tmpfs跟普通进程差不多，使用的都是某种形式的虚拟内存，至于数据存储在物理内存中还是在交换分区中，全权交由VM子系统。定义： 是一个基于内存的文件系统，它在 RAM 中存储数据，因此访问速度非常快。用途： 通常用于存储临时文件，这些文件不需要永久保存，而且频繁读写。使用 可以减少对物理磁盘的磨损，并提高性能。示例路径：常见的 挂载点包括 、、 等。持
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 859
书生浦语大模型实战营第四期：Linux前置基础
【Linux】MySQLMGR主从复制
Stringzhua的博客
10-30 793
MySQL是⽬前最流⾏的开源关系型数据库，国内⾦融⾏业也开始全⾯使⽤，其中MySQL5.7.17提出的 MGR(MySQL Group Replication)既可以很好的保证数据⼀致性⼜可以⾃动切换，具备故障检测功能、 ⽀持多节点写⼊，MGR是⼀项被普遍看好的技术。MGR(MySQL Group Replication)是MVSQL⾃带的⼀个插件，可以灵活部署。
Linux初阶——线程（Part3）：POSIX 信号量 & CP 模型变体
最新发布
m0_73093743的博客
11-02 231
只能建立一个对象的设计模式。
Linux 之 信号概念、进程、进程间通信、线程、线程同步
挥剑决浮云的博客
11-01 534
如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒，它们都会尝试对互斥锁进行加锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能再次陷入阻塞，等待下一次解锁。事实上，子进程是父进程的一个副本，譬如子进程拷贝了父进程的数据段、堆、栈以及继承了父进程打开的文件描述符，父进程与子进程并不共享这些存储空间，这是子进程对父进程相应部分存储空间的完全复制，执行fork()之后，每个进程均可修改各自的栈数据以及堆段中的变量，而并不影响另一个进程。是一族函数，而不是一个单独的函数。
【Linux】信号三部曲——产生、保存、处理
m0_74808907的博客
11-02 1329
一文带你由浅入深掌握信号产生、保存、处理！
Linux进程通信教程代码深度解析
资源摘要信息:"Linux进程通信" Linux进程通信是操作系统中非常重要的一个组成部分，它允许在同一台计算机上运行的多个进程之间交换数据或信号。在Linux系统中，进程通信（IPC）通常包括管道（Pipes）、命名管道...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值