69天探索操作系统-第35天：进程间通信 (IPC)

GoGeekBaird2025-01-12 23:26

1. 介绍

进程间通信（IPC）是一组允许进程进行通信和同步其操作的机制。IPC是现代操作系统和分布式计算的基础。它使进程能够共享数据、协调任务并高效地管理资源。

关键概念：

  • 进程隔离： 进程拥有独立的内存空间，不能直接访问彼此的内存。进程间通信（IPC）提供了一种受控的方式，使进程能够在不违反这种隔离的情况下共享数据。
  • 数据交换： IPC机制允许进程以结构化的方式交换数据，确保信息安全高效地传递。
  • 同步： 进程通常需要协调其操作，尤其是在多线程或分布式系统中。IPC 提供同步机制，以确保进程和谐地协同工作。
  • 资源共享： IPC 允许多个进程以受控和高效的方式共享系统资源，如文件、内存或网络连接。

2. IPC机制类型

2.1 管道

管道是IPC（进程间通信）中最简单的一种形式，提供相关进程（通常是父进程和子进程）之间的单向通信通道。数据以先进先出（FIFO）的方式流动，使管道非常适合基于流的 数据传输。

  • 单向通信： 管道只允许数据单向流动，从写入者流向读取者。
  • FIFO 数据流： 数据以写入时的顺序读取，确保一致性。
  • 相关进程： 管道通常用于具有父子关系的进程之间。
  • 基于流的传输： 管道非常适合连续数据流，如日志记录或实时数据处理。

2.2 消息队列

消息队列提供了一种更灵活的进程间通信（IPC）形式，允许进程之间进行双向通信。消息存储在队列中，可以按优先级顺序检索，这使得消息队列非常适合复杂的通信模式。

  • 双向通信： 与管道不同，消息队列允许发送和接收消息。
  • 基于消息的数据传输： 数据以离散的消息形式传输，这些消息可以包括优先级等元数据。
  • 优先级支持： 消息可以分配不同的优先级，使高优先级消息先被处理。
  • 系统范围内的可访问性： 消息队列可以被具有适当权限的进程访问，这使得它们适合跨系统进行进程间通信。

3. 管道细节

3.1 匿名管道实现

以下代码演示了如何创建和使用匿名管道，以实现父进程和子进程之间的通信。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>

#define BUFFER_SIZE 256

int main() {
    int pipe_fd[2];
    pid_t pid;
    char buffer[BUFFER_SIZE];

    if (pipe(pipe_fd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    pid = fork();

    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {  // Child process
        close(pipe_fd[1]);  // Close write end

        // Read from pipe
        ssize_t bytes_read = read(pipe_fd[0], buffer, BUFFER_SIZE);
        if (bytes_read > 0) {
            printf("Child received: %s\n", buffer);
        }

        close(pipe_fd[0]);
        exit(EXIT_SUCCESS);
    } else {  // Parent process
        close(pipe_fd[0]);  // Close read end

        const char *message = "Hello from parent!";
        write(pipe_fd[1], message, strlen(message) + 1);

        close(pipe_fd[1]);
        wait(NULL);  // Wait for child to finish
    }

    return 0;
}

运行代码的步骤：

  1. 编译代码：将代码保存到名为 pipe_example.c 的文件中，并使用 C 编译器（如 gcc）进行编译：
shell 复制代码 
gcc -o pipe_example pipe_example.c
  1. 运行可执行文件：执行编译后的程序：
shell 复制代码 
./pipe_example
  1. 预期输出：子进程将接收由父进程发送的消息，并将其打印到控制台：
shell 复制代码 
Child received: Hello from parent!

3.2 命名管道（先进先出队列）

命名管道，也称为FIFO，允许无关进程之间的通信。以下代码演示了如何创建和使用命名管道。

Writer进程：

c 复制代码 
// fifo_writer.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>

#define FIFO_PATH "/tmp/myfifo"

int main() {
    mkfifo(FIFO_PATH, 0666);

    printf("Opening FIFO for writing...\n");
    int fd = open(FIFO_PATH, O_WRONLY);

    const char *message = "Message through FIFO";
    write(fd, message, strlen(message) + 1);

    close(fd);
    return 0;
}

Reader进程:

c 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>

#define FIFO_PATH "/tmp/myfifo"
#define BUFFER_SIZE 256

int main() {
    char buffer[BUFFER_SIZE];

    printf("Opening FIFO for reading...\n");
    int fd = open(FIFO_PATH, O_RDONLY);

    read(fd, buffer, BUFFER_SIZE);
    printf("Received: %s\n", buffer);

    close(fd);
    unlink(FIFO_PATH);
    return 0;
}

运行代码的步骤：

  1. 编译代码：将写入器和读取器代码分别保存在不同的文件中（fifo_writer.c 和 fifo_reader.c），然后编译它们：
shell 复制代码 
gcc -o fifo_writer fifo_writer.c
gcc -o fifo_reader fifo_reader.c
  1. 运行Writer：启动Writer进程：
shell 复制代码 
./fifo_writer
  1. 运行Reader：在单独的终端中，启动Reader进程：
shell 复制代码 
./fifo_reader
  1. 预期输出：读者进程将接收到由写者进程发送的消息，并将其打印到控制台：
shell 复制代码 
Received: Message through FIFO

4. 消息队列

4.1 POSIX 消息队列实现

以下代码演示了如何创建和使用 POSIX 消息队列以进行进程间通信。

发送者进程：

c 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>
#include <sys/stat.h>
#include <fcntl.h>

#define QUEUE_NAME "/test_queue"
#define MAX_MSG_SIZE 256
#define MSG_PRIO 1

int main() {
    mqd_t mq;
    struct mq_attr attr;

    // Set queue attributes
    attr.mq_flags = 0;
    attr.mq_maxmsg = 10;
    attr.mq_msgsize = MAX_MSG_SIZE;
    attr.mq_curmsgs = 0;

    mq = mq_open(QUEUE_NAME, O_CREAT | O_WRONLY, 0644, &attr);
    if (mq == (mqd_t)-1) {
        perror("mq_open");
        exit(EXIT_FAILURE);
    }

    const char *message = "Test message";
    if (mq_send(mq, message, strlen(message) + 1, MSG_PRIO) == -1) {
        perror("mq_send");
        exit(EXIT_FAILURE);
    }

    mq_close(mq);
    return 0;
}

接收者进程：

c 复制代码 
// mqueue_receiver.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mqueue.h>
#include <sys/stat.h>
#include <fcntl.h>

#define QUEUE_NAME "/test_queue"
#define MAX_MSG_SIZE 256

int main() {
    mqd_t mq;
    char buffer[MAX_MSG_SIZE];
    unsigned int prio;

    mq = mq_open(QUEUE_NAME, O_RDONLY);
    if (mq == (mqd_t)-1) {
        perror("mq_open");
        exit(EXIT_FAILURE);
    }

    ssize_t bytes_read = mq_receive(mq, buffer, MAX_MSG_SIZE, &prio);
    if (bytes_read == -1) {
        perror("mq_receive");
        exit(EXIT_FAILURE);
    }

    printf("Received message: %s (priority: %u)\n", buffer, prio);

    mq_close(mq);
    mq_unlink(QUEUE_NAME);
    return 0;
}

运行代码的步骤：

  1. 编译代码：将发送者和接收者的代码分别保存在不同的文件中（mqueue_sender.c 和 mqueue_receiver.c），然后编译它们：
shell 复制代码 
gcc -o mqueue_sender mqueue_sender.c -lrt
gcc -o mqueue_receiver mqueue_receiver.c -lrt
  1. 运行发送者: 启动发送者进程
shell 复制代码 
./mqueue_sender
  1. 运行接受者：在单独的终端中，启动接收者进程
shell 复制代码 
./mqueue_receiver
  1. 预期输出：接收进程将接收到发送进程发送的消息，并将其及其优先级打印到控制台：
shell 复制代码 
Received message: Test message (priority: 1)

5. 高级IPC概念

5.1 消息队列属性

消息队列具有多个属性，可以配置这些属性以控制其行为。这些属性包括消息的最大数量、消息的最大大小以及队列中当前的消息数量。

c 复制代码 
struct mq_attr {
    long mq_flags;    /* Message queue flags */
    long mq_maxmsg;   /* Maximum number of messages */
    long mq_msgsize;  /* Maximum message size */
    long mq_curmsgs;  /* Number of messages currently queued */
};

5.2 非阻塞操作

消息队列可以配置为非阻塞模式，即使没有消息可用，进程也能继续执行。

c 复制代码 
mqd_t mq = mq_open(QUEUE_NAME, O_RDONLY | O_NONBLOCK);

6. 错误处理

在使用IPC机制时，正确的错误处理至关重要。以下代码演示了一种常见的错误处理模式。

c 复制代码 
#include <errno.h>

void handle_error(const char *msg) {
    perror(msg);
    exit(EXIT_FAILURE);
}

if (mq_send(mq, message, strlen(message) + 1, prio) == -1) {
    handle_error("mq_send");
}

7. 性能考虑

  • 消息大小： 较大的消息会增加开销，并可能影响性能。
  • 队列长度： 较长的队列会消耗更多的系统资源，并可能导致延迟。
  • 阻塞与非阻塞： 阻塞操作会影响系统的响应速度，而非阻塞操作则允许更有效地利用资源。
  • 优先级处理： 优先级较高的消息会优先处理，这可能会影响系统的整体性能。

8. 安全方面

  • 访问控制： 为消息队列使用适当的权限，以防止未经授权的访问。
  • 资源限制： 设置队列大小和消息数量的适当限制，以防止资源耗尽。
  • 清理： 在不再需要时始终删除消息队列，以释放系统资源。
  • 验证： 验证消息完整性和发送者真实性，以防止安全漏洞。

9. 总结

IPC机制，特别是管道和消息队列，是Unix-like系统中进程间通信的基本工具。理解这些机制及其正确实现对于开发健壮且高效的多进程应用程序至关重要。

相关推荐
云端 架构师6 分钟前
Python语言的编程范式
开发语言·后端·golang
QQ274378510911 分钟前
django基于Python对西安市旅游景点的分析与研究
java·后端·python·django
云端 架构师28 分钟前
Python语言的字符串处理
开发语言·后端·golang
造梦师阿鹏31 分钟前
【SpringBoot】用一个常见错误说一下@RequestParam属性
java·spring boot·后端·spring
小奏技术1 小时前
spring boot 2.x升级到3.x需要做哪些改动？让我一步一步带大家实践
spring boot·后端·spring cloud
熬了夜的程序员1 小时前
Go语言封装加解密包（AES/DES/RSA）
开发语言·后端·golang·密码学
Mercury_@221 小时前
功能篇：mybatis中实现缓存
java·后端
ByteBlossom6662 小时前
SQL语言的面向对象编程
开发语言·后端·golang
一颗知足的心2 小时前
Go语言之路————func
开发语言·后端·golang
布朗克1682 小时前
Springboot项目如何消费Kafka数据
spring boot·后端·kafka
热门推荐
01Dell服务器升级ubuntu 22.04失败解决02ESP-IDF学习记录（4） ESP-IDF examples目录03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明05密码学原理技术-第六章-introduction to pulibc-key cryptography06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07go下载依赖提示连接失败08华为HarmonyOS帮助应用实现在线认证服务 -- 2 FIDO免密身份认证09HCIA-datacom数通题库和录播视频资料10[Docker]使用Docker部署常见的中间件