进程间通信（IPC）：机制与实现

原创 于 2025-08-27 09:12:57 发布 · 582 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#服务器 #网络 #进程间通讯 #c++

进程间通信（IPC）：机制与实现

进程间通信（IPC，Inter-Process Communication）是操作系统中不同进程之间交换数据和协调工作的机制。由于进程拥有独立的地址空间，无法直接访问彼此的内存，因此需要专门的IPC机制来实现数据交互。本文将介绍常见的IPC方式及其特点和实现。

一、IPC的主要方式及特点

常见的进程间通信方式可分为以下几类，各有适用场景：

通信方式特点适用场景
管道（Pipe）半双工，仅用于父子进程或兄弟进程简单的命令行管道、父子进程数据传递
命名管道（FIFO）半双工，可用于任意进程间无亲缘关系的进程通信，如不同程序间交互
信号（Signal）用于通知进程发生事件，携带信息少异常处理、进程中断通知
共享内存进程共享同一块物理内存，速度最快高频、大数据量通信（如数据库、游戏引擎）
消息队列消息的链表，按类型或优先级读取异步通信，需要消息缓冲的场景
信号量（Semaphore）用于进程同步，而非传递数据控制对共享资源的访问（如临界区保护）
套接字（Socket）可跨主机通信，支持TCP/UDP网络通信、本地进程间通信（UNIX Domain Socket）

二、常用IPC机制的实现

1. 管道（Pipe）

管道是最基础的IPC机制，创建后会生成两个文件描述符：一个用于读，一个用于写，数据从写端流入、读端流出。

代码示例（父子进程通信）：

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

int main() {
    int pipefd[2];
    pid_t pid;
    char buffer[1024];
    
    // 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe failed");
        exit(EXIT_FAILURE);
    }
    
    // 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    }
    
    if (pid == 0) {  // 子进程：读数据
        close(pipefd[1]);  // 关闭写端
        
        // 从管道读取数据
        ssize_t bytes_read = read(pipefd[0], buffer, sizeof(buffer));
        if (bytes_read > 0) {
            printf("子进程收到：%.*s\n", (int)bytes_read, buffer);
        }
        
        close(pipefd[0]);  // 关闭读端
        exit(EXIT_SUCCESS);
    } else {  // 父进程：写数据
        close(pipefd[0]);  // 关闭读端
        
        const char *msg = "Hello from parent process!";
        write(pipefd[1], msg, strlen(msg));
        
        close(pipefd[1]);  // 关闭写端，触发子进程的读结束
        wait(NULL);        // 等待子进程结束
        exit(EXIT_SUCCESS);
    }
}

特点：

  • 半双工通信（数据只能单向流动）
  • 仅存在于内存中，进程退出后管道消失
  • 只能用于具有亲缘关系的进程（父子、兄弟）

2. 命名管道（FIFO）

命名管道是有文件名的管道，存在于文件系统中，任何进程只要知道文件名即可通信。

代码示例（两个独立进程通信）：

写端程序（fifo_write.c）：

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

#define FIFO_NAME "/tmp/my_fifo"

int main() {
    int fd;
    const char *msg = "Hello from FIFO writer";
    
    // 创建FIFO（如果不存在）
    mkfifo(FIFO_NAME, 0666);
    
    // 打开FIFO用于写
    fd = open(FIFO_NAME, O_WRONLY);
    if (fd == -1) {
        perror("open failed");
        exit(EXIT_FAILURE);
    }
    
    // 写入数据
    write(fd, msg, strlen(msg));
    printf("已发送: %s\n", msg);
    
    close(fd);
    // 可选：删除FIFO
    // unlink(FIFO_NAME);
    return 0;
}

读端程序（fifo_read.c）：

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

#define FIFO_NAME "/tmp/my_fifo"

int main() {
    int fd;
    char buffer[1024];
    
    // 打开FIFO用于读
    fd = open(FIFO_NAME, O_RDONLY);
    if (fd == -1) {
        perror("open failed");
        exit(EXIT_FAILURE);
    }
    
    // 读取数据
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer));
    if (bytes_read > 0) {
        printf("收到: %.*s\n", (int)bytes_read, buffer);
    }
    
    close(fd);
    return 0;
}

特点：

  • 可用于任意进程间通信，无需亲缘关系
  • 存在于文件系统中，需要显式创建和删除
  • 读写操作默认阻塞，直到另一端准备好

3. 共享内存

共享内存是效率最高的IPC方式，多个进程直接访问同一块物理内存，避免了数据拷贝。

代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/shm.h>
#include <string.h>

#define SHM_SIZE 1024  // 共享内存大小

int main() {
    int shmid;
    char *shmaddr;
    pid_t pid;
    
    // 创建共享内存段
    shmid = shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget failed");
        exit(EXIT_FAILURE);
    }
    
    // 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork failed");
        shmctl(shmid, IPC_RMID, NULL);  // 清理共享内存
        exit(EXIT_FAILURE);
    }
    
    if (pid == 0) {  // 子进程：读共享内存
        // 附加共享内存到地址空间
        shmaddr = (char *)shmat(shmid, NULL, 0);
        if (shmaddr == (char *)-1) {
            perror("shmat failed");
            exit(EXIT_FAILURE);
        }
        
        // 读取数据
        printf("子进程读取: %s\n", shmaddr);
        
        // 分离共享内存
        shmdt(shmaddr);
        exit(EXIT_SUCCESS);
    } else {  // 父进程：写共享内存
        // 附加共享内存到地址空间
        shmaddr = (char *)shmat(shmid, NULL, 0);
        if (shmaddr == (char *)-1) {
            perror("shmat failed");
            exit(EXIT_FAILURE);
        }
        
        // 写入数据
        const char *msg = "Hello from shared memory";
        strncpy(shmaddr, msg, SHM_SIZE);
        printf("父进程写入: %s\n", msg);
        
        // 等待子进程读取
        wait(NULL);
        
        // 分离并删除共享内存
        shmdt(shmaddr);
        shmctl(shmid, IPC_RMID, NULL);
        exit(EXIT_SUCCESS);
    }
}

特点：

  • 速度最快（无内核参与数据传输）
  • 需要同步机制（如信号量）防止数据竞争
  • 共享内存段由内核管理，进程退出后需显式删除

4. 信号量（Semaphore）

信号量用于进程同步，通过控制对共享资源的访问来避免竞态条件，本身不传递数据。

代码示例（控制共享资源访问）：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/sem.h>
#include <sys/wait.h>

// 信号量操作函数
void sem_operation(int semid, int op) {
    struct sembuf sb;
    sb.sem_num = 0;  // 第一个信号量
    sb.sem_op = op;  // 操作：+1释放，-1获取
    sb.sem_flg = 0;
    semop(semid, &sb, 1);
}

int main() {
    int semid;
    pid_t pid;
    
    // 创建信号量集（含1个信号量）
    semid = semget(IPC_PRIVATE, 1, IPC_CREAT | 0666);
    if (semid == -1) {
        perror("semget failed");
        exit(EXIT_FAILURE);
    }
    
    // 初始化信号量值为1（互斥锁）
    semctl(semid, 0, SETVAL, 1);
    
    // 创建两个子进程
    for (int i = 0; i < 2; i++) {
        pid = fork();
        if (pid == -1) {
            perror("fork failed");
            semctl(semid, 0, IPC_RMID);
            exit(EXIT_FAILURE);
        }
        
        if (pid == 0) {  // 子进程
            // 获取信号量（P操作）
            sem_operation(semid, -1);
            
            // 临界区：访问共享资源
            printf("子进程 %d 进入临界区\n", getpid());
            sleep(2);  // 模拟操作
            printf("子进程 %d 离开临界区\n", getpid());
            
            // 释放信号量（V操作）
            sem_operation(semid, 1);
            
            exit(EXIT_SUCCESS);
        }
    }
    
    // 等待所有子进程结束
    for (int i = 0; i < 2; i++) {
        wait(NULL);
    }
    
    // 清理信号量
    semctl(semid, 0, IPC_RMID);
    return 0;
}

特点：

  • 主要用于同步，而非数据传输
  • 常见操作：P（获取资源，信号量-1）和V（释放资源，信号量+1）
  • 支持互斥（二元信号量）和同步（计数信号量）

5. 消息队列

消息队列是内核维护的消息链表，进程可按类型发送和接收消息，实现异步通信。

代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/msg.h>
#include <string.h>

// 消息结构
struct msgbuf {
    long mtype;       // 消息类型（正数）
    char mtext[1024]; // 消息内容
};

int main() {
    int msqid;
    pid_t pid;
    struct msgbuf msg;
    
    // 创建消息队列
    msqid = msgget(IPC_PRIVATE, IPC_CREAT | 0666);
    if (msqid == -1) {
        perror("msgget failed");
        exit(EXIT_FAILURE);
    }
    
    pid = fork();
    if (pid == -1) {
        perror("fork failed");
        msgctl(msqid, IPC_RMID, NULL);
        exit(EXIT_FAILURE);
    }
    
    if (pid == 0) {  // 子进程：接收消息
        // 接收类型为1的消息
        if (msgrcv(msqid, &msg, sizeof(msg.mtext), 1, 0) == -1) {
            perror("msgrcv failed");
            exit(EXIT_FAILURE);
        }
        printf("子进程收到: %s\n", msg.mtext);
        
        // 发送回应（类型为2）
        msg.mtype = 2;
        strcpy(msg.mtext, "收到消息，谢谢！");
        if (msgsnd(msqid, &msg, strlen(msg.mtext) + 1, 0) == -1) {
            perror("msgsnd failed");
            exit(EXIT_FAILURE);
        }
        
        exit(EXIT_SUCCESS);
    } else {  // 父进程：发送消息
        // 发送类型为1的消息
        msg.mtype = 1;
        strcpy(msg.mtext, "Hello from parent");
        if (msgsnd(msqid, &msg, strlen(msg.mtext) + 1, 0) == -1) {
            perror("msgsnd failed");
            exit(EXIT_FAILURE);
        }
        
        // 接收回应（类型为2）
        if (msgrcv(msqid, &msg, sizeof(msg.mtext), 2, 0) == -1) {
            perror("msgrcv failed");
            exit(EXIT_FAILURE);
        }
        printf("父进程收到回应: %s\n", msg.mtext);
        
        wait(NULL);
        // 清理消息队列
        msgctl(msqid, IPC_RMID, NULL);
        exit(EXIT_SUCCESS);
    }
}

特点：

  • 消息按类型分类，接收方可选择特定类型消息
  • 消息存在于内核中，进程退出后消息不会丢失
  • 适合异步通信，无需双方同时运行

6. 套接字（Socket）

套接字原本用于网络通信，但在UNIX系统中，UNIX Domain Socket可用于本地进程间通信，效率高于网络套接字。

代码示例（本地套接字通信）：

服务器端（socket_server.c）：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <string.h>

#define SOCKET_PATH "/tmp/my_socket"

int main() {
    int server_fd, client_fd;
    struct sockaddr_un server_addr, client_addr;
    socklen_t client_len;
    char buffer[1024];
    
    // 创建UNIX Domain Socket
    if ((server_fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    
    // 绑定地址
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sun_family = AF_UNIX;
    strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(server_addr.sun_path) - 1);
    unlink(SOCKET_PATH);  // 移除可能存在的旧文件
    
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
    
    // 监听连接
    if (listen(server_fd, 5) == -1) {
        perror("listen failed");
        exit(EXIT_FAILURE);
    }
    
    printf("服务器等待连接...\n");
    
    // 接受连接
    client_len = sizeof(client_addr);
    if ((client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len)) == -1) {
        perror("accept failed");
        exit(EXIT_FAILURE);
    }
    
    // 接收数据
    ssize_t bytes_read = read(client_fd, buffer, sizeof(buffer));
    if (bytes_read > 0) {
        printf("收到: %.*s\n", (int)bytes_read, buffer);
    }
    
    // 发送回应
    const char *msg = "Hello from server";
    write(client_fd, msg, strlen(msg));
    
    // 清理
    close(client_fd);
    close(server_fd);
    unlink(SOCKET_PATH);
    return 0;
}

客户端（socket_client.c）：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <string.h>

#define SOCKET_PATH "/tmp/my_socket"

int main() {
    int fd;
    struct sockaddr_un addr;
    char buffer[1024];
    
    // 创建套接字
    if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    
    // 连接服务器
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path) - 1);
    
    if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("connect failed");
        exit(EXIT_FAILURE);
    }
    
    // 发送数据
    const char *msg = "Hello from client";
    write(fd, msg, strlen(msg));
    
    // 接收回应
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer));
    if (bytes_read > 0) {
        printf("收到回应: %.*s\n", (int)bytes_read, buffer);
    }
    
    close(fd);
    return 0;
}

特点：

  • 支持双向通信，接口统一（本地和网络通信使用相同API）
  • UNIX Domain Socket比网络套接字效率高（无需协议栈处理）
  • 可用于任意进程间通信，包括不同用户的进程

三、IPC方式的选择建议

  1. 简单父子进程通信：优先使用管道（Pipe），实现简单
  2. 无亲缘关系的本地进程：命名管道（FIFO）或UNIX Domain Socket
  3. 高频大数据传输：共享内存（配合信号量同步）
  4. 异步消息传递：消息队列，适合需要缓冲的场景
  5. 跨主机通信：网络套接字（TCP/UDP）
  6. 进程同步：信号量，常与共享内存配合使用

实际应用中，往往需要组合多种IPC机制（如共享内存+信号量），以兼顾效率和正确性。选择时需综合考虑通信频率、数据量、同步需求和跨平台性等因素。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

bkspiderx

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值