当前位置： 首页 > article >正文

【Linux探索学习】第二十六弹——进程通信：深入理解Linux中的进程通信

article 2025/1/17 14:05:24

Linux探索学习：

https://blog.csdn.net/2301_80220607/category_12805278.html?spm=1001.2014.3001.5482

前言：

在Linux操作系统中，进程通信（IPC）是操作系统的一项核心功能，用于在不同进程之间交换数据或信号。这种能力在多任务操作系统中尤为重要，因为进程之间通常需要协作完成复杂的任务。本篇文章将详细介绍Linux中的进程通信机制，特别是管道通信，并结合代码示例和表格总结，帮助您全面理解这些技术。

目录

为什么需要进程通信？

Linux中的进程通信机制概览

1. 管道（Pipe）通信（匿名管道）

原理

特性

系统调用

示例代码：管道的基本用法

预期结果

​编辑

管道的局限性

双向通信

2. FIFO（命名管道）

创建命名管道

示例代码：命名管道

运行步骤

预期结果

特点

3. 消息队列

示例代码

运行结果

消息队列的优点和缺点

4. 共享内存

特性

示例代码

运行结果

优缺点

总结

为什么需要进程通信？

在Linux中，每个进程都有独立的地址空间，这种隔离性保障了系统的稳定性和安全性，但也使得进程间直接访问彼此的内存成为不可能。因此，为了在不同进程之间交换数据，操作系统提供了多种IPC机制。

常见的进程通信使用场景包括：

1. 数据传输:一个进程需要将它的数据发送给另一个进程
2. 资源共享:多个进程之间共享同样的资源。
3. 通知事件:一个进程需要向另一个或一组进程发送消息，通知它(它们)发生了某种事件(如进程终止时要通知父进程)。
4. 进程控制:有些进程希望完全控制另一个进程的执行(如Debug进程)，此时控制进程希望能够拦截另个进程的所有陷入和异常，并能够及时知道它的状态改变。

Linux中的进程通信机制概览

Linux 提供了多种进程通信方式，适用于不同场景。以下是常见的几种机制：

通信方式描述优点缺点
管道（Pipe）单向或双向数据流，父子进程间通信简单、效率高只能在亲缘进程之间通信，不适合大数据量传输
FIFO（命名管道）像管道一样，但可用于无亲缘关系的进程间通信灵活性更高性能较低
消息队列基于消息的异步通信方式可传递结构化消息管理复杂，性能受限
共享内存不同进程共享内存区域进行通信高效，适合大数据量传输同步机制复杂，需额外处理同步问题
信号量用于进程同步和资源管理简单、轻量级不适合复杂的通信场景
套接字（Socket）网络通信和本地进程通信的强大工具强大且灵活，支持多种协议实现较复杂，需学习成本

接下来，我们详细探讨这些通信方式，重点讲解管道和命名管道。（信号量和套接字的内容不作为重点）

1. 管道（Pipe）通信（匿名管道）

管道是Linux中最简单、最常用的进程通信方式之一。它提供了一个单向数据流，可以在父子进程之间传递数据。

原理

上面内容补充说明:

  1. 内存级文件:当我们进程打开一个文件并向里面写入时，是要先写入缓冲区的，然后系统再刷新进入磁盘中的，但是文件其实并不是一定要存在在磁盘中的，也可以直接存在内存中的，内存级文件与普通文件的区别就是不会刷新到显示屏中，其它基本一致
  2. 子进程在创建时会对父进程进行拷贝，files struct也会拷贝，但是拷贝方式类似于指针拷贝的浅拷贝，只会拷贝结构体，并不会把父进程打开的文件拷贝一份一样的，所以子进程的文件描述符与父进程一样，与父进程用的相同的文件(比如:当我们创建一个父子进程时，在不同的窗口打开它们，让这两个进程同时向显示屏上刷新内容时，都会刷新在父进程的显示屏上)
  3. 实现进程通信的前提就是让不同的进程看到同一份“资源”，所以我们就可以让父进程和子进程通过这样的内存级文件建立联系
  4. 管道的本质就是内存级文件
特性

  1. 单向性：标准管道是单向的，即数据只能沿一个方向流动。

  2. 亲缘关系：标准管道只能用于具有亲缘关系的进程间通信。

  3. 内核缓冲区：管道依赖于内核缓冲区，数据写入后，只有在被读取时才会释放缓冲区。

系统调用

Linux 提供以下系统调用与管道相关：

  • pipe(): 创建一个管道，返回两个文件描述符：fd[0]（用于读）和 fd[1]（用于写）。

示例代码：管道的基本用法

以下代码展示了父子进程通过管道进行通信：

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

int main() {
    int pipefd[2];
    pid_t pid;
    char buffer[128];

    // 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe failed");
        return 1;
    }

    pid = fork(); // 创建子进程
    if (pid < 0) {
        perror("fork failed");
        return 1;
    } else if (pid == 0) { // 子进程
        close(pipefd[1]); // 关闭写端
        read(pipefd[0], buffer, sizeof(buffer)); // 读取数据
        printf("Child process received: %s\n", buffer);
        close(pipefd[0]); // 关闭读端
    } else { // 父进程
        close(pipefd[0]); // 关闭读端
        const char *msg = "Hello from parent!";
        write(pipefd[1], msg, strlen(msg) + 1); // 写入数据
        close(pipefd[1]); // 关闭写端
        wait(NULL); // 等待子进程结束
    }

    return 0;
}
预期结果
Child process received: Hello from parent!
管道的局限性

  1. 单向数据流：默认情况下，管道只支持单向通信。

  2. 仅限亲缘进程：标准管道仅适用于父子进程之间。

  3. 容量限制：管道的内核缓冲区有限，写入数据量过大会阻塞。（不同的操作系统内核下内存级文件的大小是不同的，默认规定的是4kb，但比如centos7.0下就是16kb）

双向通信

通过创建两个管道，可以实现双向通信（不常用）。例如：

int pipe1[2], pipe2[2];
pipe(pipe1);
pipe(pipe2);
// 使用 pipe1 进行父->子通信，使用 pipe2 进行子->父通信。

2. FIFO（命名管道）

FIFO（命名管道）克服了标准管道只能在亲缘进程间通信的限制。它是文件系统中的一种特殊文件，允许无亲缘关系的进程间通信。

创建命名管道

命名管道可以使用以下方法创建：

  1. 命令行工具：使用 mkfifo 命令。

  2. 系统调用：使用 mkfifo() 函数。具体方式可以通过man手册来查看

    man mkfifo
示例代码：命名管道

以下代码演示了两个独立进程通过命名管道通信：

写入进程：writer.c

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

int main() {
    const char *fifo = "/tmp/my_fifo";
    mkfifo(fifo, 0666); // 创建命名管道

    int fd = open(fifo, O_WRONLY); // 打开管道写端
    const char *msg = "Hello from writer!";
    write(fd, msg, strlen(msg) + 1); // 写入数据
    close(fd); // 关闭文件描述符

    return 0;
}

读取进程：reader.c

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

int main() {
    const char *fifo = "/tmp/my_fifo";
    char buffer[128];

    int fd = open(fifo, O_RDONLY); // 打开管道读端
    read(fd, buffer, sizeof(buffer)); // 读取数据
    printf("Reader process received: %s\n", buffer);
    close(fd); // 关闭文件描述符

    return 0;
}
运行步骤

  1. 启动 reader 进程：

    ./reader

  2. 启动 writer 进程：

    ./writer
预期结果
Reader process received: Hello from writer!
特点

  1. 支持无亲缘关系的进程通信。

  2. 可以通过文件路径访问。

  3. 数据读完即从管道中移除。

3. 消息队列

消息队列允许进程以消息的形式传递数据，并支持消息的优先级。

示例代码

发送端代码：

#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <string.h>

struct msg_buffer {
    long msg_type;
    char msg_text[100];
};

int main() {
    key_t key;
    int msgid;

    // 创建唯一的键值
    key = ftok("progfile", 65);

    // 创建消息队列
    msgid = msgget(key, 0666 | IPC_CREAT);

    struct msg_buffer message;
    message.msg_type = 1;

    strcpy(message.msg_text, "Hello, Message Queue!");

    // 发送消息
    msgsnd(msgid, &message, sizeof(message), 0);

    printf("Data sent: %s\n", message.msg_text);

    return 0;
}

接收端代码：

#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <string.h>

struct msg_buffer {
    long msg_type;
    char msg_text[100];
};

int main() {
    key_t key;
    int msgid;

    // 创建唯一的键值
    key = ftok("progfile", 65);

    // 获取消息队列
    msgid = msgget(key, 0666 | IPC_CREAT);

    struct msg_buffer message;

    // 接收消息
    msgrcv(msgid, &message, sizeof(message), 1, 0);

    printf("Data received: %s\n", message.msg_text);

    // 删除消息队列
    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}
运行结果

运行发送端程序后，再运行接收端程序，结果如下：

发送端输出：

Data sent: Hello, Message Queue!

接收端输出：

Data received: Hello, Message Queue!
消息队列的优点和缺点
优点缺点
支持优先级队列，消息可以按优先级读取需要显式创建和销毁队列，操作较复杂
数据结构化，适合传递小型消息消息大小受系统限制，传递大数据性能较差
进程间解耦，无需直接建立父子关系存在队列上限，可能导致阻塞或失败

4. 共享内存

共享内存是Linux中效率最高的进程通信方式，因为数据直接存储在内存中，无需拷贝。它非常适合用于传递大规模数据。

特性

  1. 高效：内存共享避免了数据拷贝，通信效率高。

  2. 需同步机制：由于共享内存区域可以同时被多个进程访问，需要使用信号量或其他同步机制防止数据冲突。

  3. 适合大数据量传输：特别适合需要频繁通信的场景。

示例代码

以下展示了共享内存的基本用法。

创建和写入共享内存的进程：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main() {
    // 创建唯一键值
    key_t key = ftok("shmfile", 65);

    // 创建共享内存段
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);

    // 将共享内存附加到进程地址空间
    char *str = (char *) shmat(shmid, (void *)0, 0);

    // 写入数据
    strcpy(str, "Hello, Shared Memory!");

    printf("Data written to shared memory: %s\n", str);

    // 分离共享内存
    shmdt(str);

    return 0;
}

读取共享内存的进程：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main() {
    // 创建唯一键值
    key_t key = ftok("shmfile", 65);

    // 获取共享内存段
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);

    // 将共享内存附加到进程地址空间
    char *str = (char *) shmat(shmid, (void *)0, 0);

    // 读取数据
    printf("Data read from shared memory: %s\n", str);

    // 分离共享内存
    shmdt(str);

    // 销毁共享内存
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}
运行结果

写入进程输出：

Data written to shared memory: Hello, Shared Memory!

读取进程输出：

Data read from shared memory: Hello, Shared Memory!
优缺点
优点缺点
高效，适合大数据传输需显式同步，复杂度较高
数据共享无需频繁拷贝进程需要协同管理内存
持续性强，共享内存在进程间保持有效易出现数据一致性问题

总结

Linux中的进程通信机制为开发者提供了多种灵活的工具，应根据应用场景选择合适的方式：

  1. 管道与命名管道：简单场景下的首选，适用于中小型数据流。

  2. 消息队列：适合需要传递结构化消息的异步场景。

  3. 共享内存：性能需求高或传输大数据时的最佳选择，但需同步机制配合。

通信机制数据传输方向数据持久性是否需同步优化场景
管道（Pipe）单向瞬时不需要父子进程通信，简单小型数据流
FIFO单向瞬时不需要无亲缘关系的进程间通信
消息队列单/多向瞬时不需要传递结构化消息，任务解耦
共享内存双向持久需要频繁通信或大数据传输

以上就是进程通信的主要内容，其中我们重点先要理解管道通信的原理，学习进程通信对我们后期学习网络部分内容有着很重要的铺垫作用。

本篇笔记（不完整，后期会更新）：

感谢各位大佬观看，创作不易，还请各位大佬点赞支持！！！


http://www.kler.cn/a/506499.html

相关文章：

  • ubuntu20.04安装MySQL5.7
  • 语音合成的预训练模型
  • Yolov8 目标检测剪枝学习记录
  • 【前端】框架-构建-包管理-语言-语法-生态工具
  • Django框架：python web开发
  • 【混合开发】CefSharp+Vue 解决Cookie问题
  • 网关相关知识
  • 计算机网络 网络层 2
  • PyCharm与GitHub完美对接: 详细步骤指南
  • 基于YOLOv8的卫星图像中船只检测系统
  • 用行动回应“实体清单”，智谱发布了一系列新模型
  • Python 如何操作 PDF 文件？
  • 2025-01-16 思考-人生下半场的归途-那温和的良夜
  • 运行fastGPT 第四步 配置ONE API 添加模型
  • 干货答疑分享记录：as导入问题，LSP含义，分屏进入SplashScreen
  • windows 电源选项卓越性能开启
  • kotlin的dagger hilt依赖注入
  • AI学习之自然语言处理（NLP）
  • 网络安全——常用语及linux系统
  • VUE学习笔记5__vue指令v-html
  • RK3576 Android14 状态栏和导航栏增加显示控制功能
  • 玩转大语言模型——使用graphRAG+Ollama构建知识图谱
  • Linux Top 命令 load average 指标解读
  • 正式开源，Doris Operator 支持高效 Kubernetes 容器化部署方案
  • JS宏进阶: 工厂函数与构造函数
  • 【深度学习】PyTorch ：调用残差网络(ResNet)