进程、线程和进程间通信课程 Day6学习要点总结

最新推荐文章于 2025-12-15 15:14:09 发布
原创 最新推荐文章于 2025-12-15 15:14:09 发布 · 913 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#学习 #服务器 #linux

一、IPC 基本概念

定义：进程间通信（InterProcess Communication，IPC）是指进程与进程之间交换信息的过程。

常用通信方式：

  • 无名管道（pipe）
  • 有名管道（fifo）
  • 信号（signal）
  • 共享内存 (mmap)
  • 套接字（socket）

二、无名管道（pipe）

（一）特点

  1. 只能用于具有亲缘关系的进程之间的通信（如父子进程、兄弟进程）
  2. 单工通信模式，具有固定的读端和写端
  3. 创建时返回两个文件描述符：pfd[0]用于读，pfd[1]用于写

（二）创建函数

#include <unistd.h>
int pipe(int pfd[2]);
  • 参数：pfd为包含两个整数的数组，用于存储文件描述符
  • 返回值：成功返回 0，失败返回 - 1

（三）代码示例 1：基本父子进程通信

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main() {
    int pfd[2];  // 文件描述符
    int re;      // 返回值
    char buf[20] = {0};
    pid_t pid;

    re = pipe(pfd);
    if (re < 0) {
        perror("pipe");
        return 0;
    }

    pid = fork();
    if (pid < 0) {
        perror("fork");
        return 0;
    } else if (pid == 0) {
        // 子进程：写管道
        while (1) {
            strcpy(buf, "hhahahahah");
            write(pfd[1], buf, strlen(buf));
            sleep(1);
        }
    } else {
        // 父进程：读管道
        while (1) {
            re = read(pfd[0], buf, 20);
            if (re > 0) {
                printf("read pipe=%s\n", buf);
            }
        }
    }
}
运行结果截图说明
read pipe=hhahahahah
read pipe=hhahahahah
read pipe=hhahahahah
read pipe=hhahahahah
  • 截图显示父进程持续从管道读取子进程写入的数据。

（四）代码示例 2：多进程共享管道（父进程读，两子进程写）

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main() {
    int pfd[2];
    int i;
    int re;
    char buf[40] = {0};
    pid_t pid;

    re = pipe(pfd);
    if (re < 0) {
        perror("pipe");
        return 0;
    }

    printf("%d,%d\n", pfd[0], pfd[1]);

    for (i = 0; i < 2; i++) {
        pid = fork();
        if (pid < 0) {
            perror("fork");
            return 0;
        } else if (pid > 0) {
            // 父进程继续创建子进程
        } else {
            // 子进程跳出循环
            break;
        }
    }

    if (i == 2) {  // 父进程
        close(pfd[1]);
        while (1) {
            memset(buf, 0, 40);
            re = read(pfd[0], buf, 40);
            if (re > 0) {
                printf("%s\n", buf);
            }
        }
        return 0;
    }
    if (i == 1) {  // 子进程1
        close(pfd[0]);
        while (1) {
            strcpy(buf, "this is 2 process");
            write(pfd[1], buf, strlen(buf));
            usleep(930000);
        }
        return 0;
    }
    if (i == 0) {  // 子进程0
        close(pfd[0]);
        while (1) {
            strcpy(buf, "this is 1 process");
            write(pfd[1], buf, strlen(buf));
            sleep(1);
        }
        return 0;
    }
}
运行结果截图说明
3,4
this is 1 processthis is 2 process
this is 2 process
this is 1 process
this is 2 process
this is 1 process
this is 2 process
this is 1 process
this is 2 process
this is 1 process
this is 2 process
this is 1 process
this is12 process
this is 1 process
this is 2 process
this is 1 process
  • 截图显示父进程同时读取两个子进程写入管道的数据，数据交替输出。

（五）无名管道读写特性

1. 读管道
  • 管道中有数据：read返回实际读到的字节数。
  • 管道中无数据：
    • 写端全部关闭：read返回 0（类似文件结尾）。
    • 写端未全部关闭：read阻塞等待。
2. 写管道
  • 读端全部关闭：进程异常终止（可通过捕捉SIGPIPE信号避免终止）。
  • 读端未全部关闭：
    • 管道已满（64K）：write阻塞。
    • 管道未满：write写入数据并返回实际字节数。

（六）读写特性代码示例

1. 写端关闭时读管道
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main() {
    int pfd[2];
    int re;
    char buf[20] = {0};
    pid_t pid;

    re = pipe(pfd);
    if (re < 0) {
        perror("pipe");
        return 0;
    }

    printf("%d,%d\n", pfd[0], pfd[1]);

    pid = fork();
    if (pid < 0) {
        perror("fork");
        return 0;
    } else if (pid > 0) {
        // 父进程关闭读写端
        close(pfd[0]);
        close(pfd[1]);
        int j = 0;
        while (1) {
            j++;
            strcpy(buf, "hhahahahah");
            sleep(1);
        }
    } else {
        // 子进程关闭写端
        close(pfd[1]);
        sleep(30000);
        exit(0);
        while (1) {
            re = read(pfd[0], buf, 20);
            if (re > 0) {
                printf("read pipe=%s\n", buf);
            } else if (re == 0) {
                printf("re=0\n");
            }
        }
    }
}
运行结果截图说明
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
re=0
  • 截图显示当管道写端全部关闭后，读端read返回 0。
2. 写端未关闭时读管道（阻塞）
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main() {
    int pfd[2];
    int re;
    char buf[20] = {0};
    pid_t pid;

    re = pipe(pfd);
    if (re < 0) {
        perror("pipe");
        return 0;
    }

    printf("%d,%d\n", pfd[0], pfd[1]);

    pid = fork();
    if (pid < 0) {
        perror("fork");
        return 0;
    } else if (pid > 0) {
        // 父进程写管道
        close(pfd[0]);
        while (1) {
            strcpy(buf, "hhahahahah");
            write(pfd[1], buf, strlen(buf));
            sleep(1);
        }
    } else {
        // 子进程关闭写端并休眠
        close(pfd[1]);
        sleep(30000);
        exit(0);
        while (1) {
            re = read(pfd[0], buf, 20);
            if (re > 0) {
                printf("read pipe=%s\n", buf);
            } else if (re == 0) {
                printf("re=0\n");
            }
        }
    }
}
3. 读端关闭时写管道（进程终止）
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main() {
    int pfd[2];
    int re;
    char buf[20] = {0};
    pid_t pid;

    re = pipe(pfd);
    if (re < 0) {
        perror("pipe");
        return 0;
    }

    printf("%d,%d\n", pfd[0], pfd[1]);

    pid = fork();
    if (pid < 0) {
        perror("fork");
        return 0;
    } else if (pid > 0) {
        // 父进程写管道
        close(pfd[0]);
        while (1) {
            strcpy(buf, "hhahahahah");
            write(pfd[1], buf, strlen(buf));
            sleep(1);
        }
    } else {
        // 子进程关闭读写端
        close(pfd[1]);
        close(pfd[0]);
        sleep(30000);
        exit(0);
        while (1) {
            re = read(pfd[0], buf, 20);
            if (re > 0) {
                printf("read pipe=%s\n", buf);
            } else if (re == 0) {
                printf("re=0\n");
            }
        }
    }
}
4. 管道已满时写阻塞
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main() {
    int pfd[2];
    int re;
    char buf[20] = {0};
    pid_t pid;

    re = pipe(pfd);
    if (re < 0) {
        perror("pipe");
        return 0;
    }

    printf("%d,%d\n", pfd[0], pfd[1]);

    pid = fork();
    if (pid < 0) {
        perror("fork");
        return 0;
    } else if (pid > 0) {
        // 父进程大量写入数据
        close(pfd[0]);
        int j = 0;
        while (1) {
            j++;
            strcpy(buf, "hhahahahah");
            for (int i = 0; i < 1000; i++) {
                write(pfd[1], buf, strlen(buf));
            }
            printf("write %d times\n", j);
            sleep(1);
        }
    } else {
        // 子进程关闭写端并休眠
        close(pfd[1]);
        sleep(30000);
        exit(0);
        while (1) {
            re = read(pfd[0], buf, 20);
            if (re > 0) {
                printf("read pipe=%s\n", buf);
            } else if (re == 0) {
                printf("re=0\n");
            }
        }
    }
}

三、有名管道（FIFO）

（一）创建函数

#include <unistd.h>
#include <fcntl.h>
int mkfifo(const char *path, mode_t mode);
  • 参数：
    • path：管道文件路径
    • mode：管道文件权限（如 0666）
  • 返回值：成功返回 0，失败返回 - 1

（二）打开方式

  1. open(const char *path, O_RDONLY);
  2. open(const char *path, O_RDONLY | O_NONBLOCK);
  3. open(const char *path, O_WRONLY);
  4. open(const char *path, O_WRONLY | O_NONBLOCK);

（三）特点

  1. 支持非亲缘关系进程通信
  2. 通过路径名操作，文件系统中可见但内容存于内存
  3. 使用文件 IO 操作
  4. 遵循先进先出（FIFO）规则
  5. 不支持lseek操作
  6. 单工读写

（四）代码示例 1：写端程序

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

int main() {
    int re;
    int fd;
    char buf[32];

    // 创建有名管道
    re = mkfifo("/myfifo", 0666);
    if (re < 0) {
        perror("mkfifo");
    }

    // 以只写方式打开管道
    fd = open("/myfifo", O_WRONLY);
    if (fd < 0) {
        perror("open");
        return 0;
    }

    printf("after open\n");

    // 从标准输入读取数据并写入管道
    while (1) {
        fgets(buf, 32, stdin);
        write(fd, buf, strlen(buf));
    }
}

（五）代码示例 2：读端程序

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

int main() {
    int re;
    int fd;
    char buf[32];

    // 以只读方式打开管道
    fd = open("/myfifo", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 0;
    }

    printf("after open\n");

    // 从管道读取数据并输出
    while (1) {
        re = read(fd, buf, 32);
        if (re > 0) {
            printf("read fifo=%s\n", buf);
        } else if (re == 0) {
            exit(0);
        }
    }
}

（六）注意事项

  1. 不建议以O_RDWR模式打开 FIFO 文件，行为未明确定义。
  2. O_NONBLOCK选项：
    • 读打开时：非阻塞模式下，若无写端打开仍返回成功；阻塞模式下，等待写端打开。
    • 写打开时：非阻塞模式下，若无读端打开返回 - 1；阻塞模式下，等待读端打开。
  3. 数据完整性：多个进程写同一管道时，若写入数据长度≤PIPE_BUF（4K），系统确保数据不交错。
【零散知识点总结2】
weixin_44543307的博客
03-09 6628
大部分知识点来源于网络，知道的可以在评论区贴上来源喔 内容涵盖：MySQL、Spring、Spring Boot、Spring Cloud、RabbitMQ、Kafka、 Linux 等技术栈 零散知识点总结2MySQLMySQL 中有哪几种锁？MySQL 中有哪些不同的表格？简述在 MySQL 数据库中 MyISAM 和 InnoDB 的区别 MySQL MySQL 中有哪几种锁？ 1、表级锁：开销小，加锁快；不会出现死锁；锁定粒度大，发生锁冲突的概率最高，并发度最低。 2、行级锁：开销大，加锁慢；会出现
javase学习笔记，学习时间一个月，发布笔记进度1/3
m0_60726300的博客
04-10 2190
1. Java基本语法 1.1 语言概述 1.1.1 整体语言概述 1.1.2 Java语言概述 1.1.2.1 基础常识 软件：即一系列按照特定顺序组织的计算机数据和指令集合。分为系统软件和应用软件 系统软件：Windows，mac os，linux，unix，android，ios，… 应用软件：word，ppt，画图板 人机交互方式：图形化界面vs命令行方式 应用程序=算法+数据结构 1.1.2.2 计算机语言的发展迭代史 第一代：机器语言 第二代：汇编语言 第三代：高级语言 面向过程：C，P
进程、线程和进程间通信课程 Day2学习要点总结
m0_74283670的博客
06-20 744
文档主要分为三个部分：exec 函数族、守护进程（Daemon Process）和 GDB 调试多进程程序。
进程、线程和进程间通信课程 Day7学习要点总结
m0_74283670的博客
06-27 623
addr：指定映射内存地址（通常设为 NULL，由系统自动分配）length：映射区域字节数（必须 > 0）prot：内存访问权限（PROT_READ/WRITE/EXEC/NONE）flags：映射标志（MAP_SHARED/PRIVATE/FIXED/ANONYMOUS）fd：映射文件句柄（匿名映射时为 - 1）offset：文件映射偏移量（需为 0 或 4K 整数倍）
进程、线程和进程间通信课程 Day5学习要点总结
m0_74283670的博客
06-24 960
命令查看线程信息的结果，列出了当前程序中的三个线程（ID 为 1、2、3），以及每个线程的目标 ID 和当前执行的帧。此截图显示了在 GDB 中设置断点（第 5 行）并运行程序后，线程停在断点处的情况，表明调试器成功捕获到线程的执行。后重新运行程序，此时只有当前线程（Thread 2）停在断点 处，其他线程被暂停，便于单独调试当前线程。命令切换到 ID 为 3 的线程后，调试器切换到该线程的执行上下文， 并停在该线程的断点处。该截图显示了设置线程调度锁为。
进程、线程和进程间通信课程 Day1学习要点总结
m0_74283670的博客
06-20 1051
程序：存放在磁盘上的指令和数据的有序集合（静态文件）。进程：执行程序时分配资源的总称，是程序的一次执行过程（动态过程）。
进程、线程和进程间通信课程 Day3学习要点总结
m0_74283670的博客
06-22 1133
包括线程的创建、结束、参数传递、回收、分离等知识点，以及相关的代码示例和编译错误分析.
进程、线程和进程间通信课程 Day4学习要点总结
m0_74283670的博客
06-22 912
本章是线程的取消 、清理，互斥和同步，以及互斥锁、读写锁和死锁的内容。
进程、线程和进程间通信 DAY1笔记
weixin_66422840的博客
03-23 111
day01 进程的创建和回收
【操作系统-Day 18】进程与线程：从概念到实战，一文彻底搞懂如何选择
吴师兄大模型的博客
08-18 1140
在操作系统中，进程和线程是两个绕不开的核心概念，它们是并发编程的基石，也是面试中的高频考点。经过前面多篇文章的铺垫，我们已经分别探讨了进程的生命周期、调度算法以及线程的实现模型。然而，许多同学对它们之间的关系依然感到模糊：“它们到底有什么区别？又有什么联系？在我的项目中，究竟该用多进程还是多线程？” 本文作为第二阶段“进程与线程管理”的收官之作，旨在彻底厘清进程与线程的“恩怨情仇”。我们将从核心定义出发，通过生动的比喻、多维度的深度对比，最终落脚于实际的场景选择，助你构建一幅清晰、完整、可应用的知识图谱。
C 语言Day 01 学习总结
猪猪侠
11-19 1069
【代码】C 语言Day 01 学习总结。
深入解析day14_多线程编程技术要点
多线程间通信通常使用wait()、notify()和notifyAll()方法。这些方法定义在Object类中，因此所有的Java对象都可以使用这些方法来进行线程间的协作。 ### 线程池 为了减少线程创建和销毁的开销，可以使用线程池。...
探索Python进阶之路：第26天核心要点
2. **多进程编程**：学习如何创建和管理Python中的进程，了解进程间通信的方法。 3. **正则表达式**：掌握正则表达式的语法和使用方法，用于字符串模式匹配和处理。 4. **测试框架**：介绍Python中的单元测试框架...
最全面、最详细web前端面试题及答案总结
热门推荐
HanXiaoXi_yeal的博客
02-01 3万+
2021最全面、最详细web前端面试题及答案总结 总结不易，希望可以帮助到即将面试或还在学习中的web前端小伙伴，祝面试顺利，拿高薪！ 本章是HTML考点的⾮重难点，因此我们采⽤简略回答的⽅式进⾏撰写，所以不会有太多详细的解释。我们约定，每个问题后我们标记『✨ 』的为⾼频⾯试题 doctype的作⽤是什么？✨ DOCTYPE是html5标准⽹⻚声明，且必须声明在HTML⽂档的第⼀⾏。来告知浏览器的解析器⽤什么⽂档标准解析这个 ⽂档，不同的渲染模式会影响到浏览器对于 CSS 代码甚⾄ JavaScript
运放学习笔记
Z97371539的博客
12-13 558
单电源运放是指仅使用单一电源电压（例如，+5V）和地（0V）作为电源供给的运放。也就是说，它只需要一个正电压和地作为参考电压，而不需要负电压。
Android学Dart学习笔记第十四节 库和导库
weixin_44656996的博客
12-15 693
其他语言中的访问修饰符关键字提供了更细粒度的控制，而Dart使用下划线和基于库的隐私提供了直接的配置机制，有助于高效实现动态访问，并改进了树抖动（死代码消除）。库不仅提供api，还是隐私的单位：以下划线（_）开头的标识符只在库内部可见。当你导入的多个库中，使用了相同的类名时，可以为库起个别名，使用 别名.类名 明确指定所引用的类。使用import来指定如何在另一个库的作用域中使用来自一个库的命名空间。带有通配符_的导入前缀是不绑定的，但可以访问该库中的非私有扩展。
Kamailio的学习
2301_79965178的博客
12-12 597
摘要：本文详细介绍了Kamailio SIP服务器的架构与配置。Kamailio是一款支持高并发、多协议的高性能SIP服务器，采用模块化设计，包含150多个功能模块。文章从配置文件结构（全局参数、模块设置、路由区块）入手，深入解析其多进程模型、Epoll多路复用机制、共享内存和锁定系统等底层实现。重点阐述了Kamailio处理SIP消息的完整流程，包括请求/响应处理、进程间通信等核心机制，并展示了通过kamcmd命令查看进程状态的实践示例。
后端springboot框架入门学习--第一篇
最新发布
m0_65853019的博客
12-15 525
的。
（HaloOS 基于TC397学习笔记）二、配置工具VCOS Studio使用探索
April的博客
12-11 825
本文介绍了如何使用HaloOS的VCOS Studio工具配置和编译TC397开发板的rt_demo工程。
深入Linux系统编程：进程线程与进程间通信
- 套接字既可以用于同一台主机上的进程通信，也可以用于网络中不同主机间的进程通信。 在学习Linux进程线程编程时，除了了解这些理论知识之外，还需要掌握实际的操作和编程技巧，例如使用fork()创建新进程、使用...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值