进程间通信（IPC）机制详解

作者：Rare-30

219 次浏览

6 次

2026-1-20

编辑推荐:

本文介绍了五种常用的IPC方式：管道、信号、共享内存、消息队列和信号量，并附上相关函数的用法示例。希望能为大家提供一些参考或帮助。
文章来自于博客园，由火龙果Linda编辑推荐。

在操作系统中，进程间通信（Inter-Process Communication, IPC）是不同进程间交换数据与同步操作的机制。本文将详细讲解五种常用的IPC方式：管道、信号、共享内存、消息队列和信号量，并附上相关函数的用法示例。

1. 管道（Pipe）

管道是Unix/Linux中最古老的IPC形式，分为匿名管道和命名管道两种。

匿名管道

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

pipefd[0]: 读端
pipefd[1]: 写端
返回值：成功返回0，失败返回-1

示例代码：

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

int main() {
    int pipefd[2];
    char buf[20];

    if (pipe(pipefd) == -1) {
        perror("pipe");
        return 1;
    }

     pid_t pid = fork();
    if (pid == 0) { // 子进程
        close(pipefd[0]); // 关闭读端
        write(pipefd[1], "Hello, Parent!", 14);
        close(pipefd[1]);
    } else { // 父进程
        close(pipefd[1]); // 关闭写端
        read(pipefd[0], buf, sizeof(buf));
        printf("Parent received: %s\n", buf);
        close(pipefd[0]);
        wait(NULL);
    }
    return 0;
}

命名管道（FIFO）

#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);

创建命名管道文件
mode参数指定文件权限

使用流程：

1.创建FIFO：mkfifo("/tmp/myfifo", 0666)

2.进程A：open("/tmp/myfifo", O_WRONLY) 并写入数据

3.进程B：open("/tmp/myfifo", O_RDONLY) 并读取数据

2. 信号（Signal）

信号是异步通信机制，用于通知进程发生了某个事件。

常用函数

#include <signal.h>
void (*signal(int signum, void (*handler)(int)))(int);
int kill(pid_t pid, int sig);
int raise(int sig);
unsigned int alarm(unsigned int seconds);

常见信号：

SIGINT (2): 终端中断(Ctrl+C)
SIGKILL (9): 强制终止
SIGSEGV (11): 段错误
SIGALRM (14): 定时器信号

示例代码：

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

void handler(int sig) {
printf("Received signal: %d\n", sig);
}

int main() {
    signal(SIGINT, handler); // 注册SIGINT处理函数
    signal(SIGALRM, handler); // 注册SIGALRM处理函数

    alarm(3); // 3秒后发送SIGALRM

    while(1) {
        pause(); // 等待信号
    }
    return 0;
}

3. 共享内存（Shared Memory）

共享内存允许多个进程访问同一块内存区域，是最快的IPC方式。

关键函数

#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
void *shmat(int shmid, const void *shmaddr, int shmflg);
int shmdt(const void *shmaddr);
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

使用步骤：

1.创建/获取共享内存段：shmget()

2.附加到进程地址空间：shmat()

3.读写共享内存

4.分离共享内存：shmdt()

5.控制共享内存（删除等）：shmctl()

示例代码：

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

#define SHM_SIZE 1024

int main() {
    key_t key = ftok("/tmp", 'A');
    int shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0666);

    if (shmid == -1) {
        perror("shmget");
        return 1;
    }

    char *shm_ptr = (char*)shmat(shmid, NULL, 0);
    if (shm_ptr == (void*)-1) {
        perror("shmat");
        return 1;
    }

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

    // 读取数据（在另一个进程中）
    // printf("Read from shared memory: %s\n", shm_ptr);

    shmdt(shm_ptr);
    shmctl(shmid, IPC_RMID, NULL); // 删除共享内存
    return 0;
}

4. 消息队列（Message Queue）

消息队列允许进程通过发送/接收消息来通信。

关键函数

#include <sys/msg.h>
int msgget(key_t key, int msgflg);
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

消息结构：

struct msgbuf {
long mtype; // 消息类型
char mtext[1]; // 消息数据
};

示例代码：

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

struct msgbuf {
long mtype;
char mtext[100];
};

int main() {
    key_t key = ftok("/tmp", 'B');
    int msgid = msgget(key, IPC_CREAT | 0666);

    struct msgbuf msg;
    msg.mtype = 1;
    strcpy(msg.mtext, "Hello, Message Queue!");

    // 发送消息
    if (msgsnd(msgid, &msg, sizeof(msg.mtext), 0) == -1) {
        perror("msgsnd");
        return 1;
    }

    // 接收消息（在另一个进程中）
    // if (msgrcv(msgid, &msg, sizeof(msg.mtext), 1, 0) == -1) {
    // perror("msgrcv");
    // return 1;
    // }
// printf("Received: %s\n", msg.mtext);

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

5. 信号量（Semaphore）

信号量用于进程间的同步，控制对共享资源的访问。

关键函数

#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);
int semop(int semid, struct sembuf *sops, unsigned nsops);
int semctl(int semid, int semnum, int cmd, ...);

操作结构体：

struct sembuf {
    unsigned short sem_num; // 信号量编号
    short sem_op; // 操作（正数加，负数减）
    short sem_flg; // 标志（通常为0）
};

示例代码：

#include <stdio.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <unistd.h>

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

int main() {
     key_t key = ftok("/tmp", 'C');
    int semid = semget(key, 1, IPC_CREAT | 0666);

     union semun arg;
    arg.val = 1; // 初始值设为1（二进制信号量）
    semctl(semid, 0, SETVAL, arg);

    struct sembuf op_lock = {0, -1, 0}; // P操作
    struct sembuf op_unlock = {0, 1, 0}; // V操作

    // 加锁
    semop(semid, &op_lock, 1);

    printf("Critical section start\n");
    sleep(2); // 模拟临界区操作
    printf("Critical section end\n");

    // 解锁
    semop(semid, &op_unlock, 1);

    semctl(semid, 0, IPC_RMID); // 删除信号量
    return 0;
}

IPC方式对比

机制	速度	复杂度	适用场景
管道	中等	低	父子进程间简单通信
命名管道	中等	中	任意进程间流式通信
信号	快	中	事件通知、简单控制
共享内存	最快	高	大数据量、高性能通信
消息队列	中	中高	结构化的进程间通信
信号量	快	高	进程同步、资源访问控制

总结

不同的IPC机制适用于不同的场景：

管道/命名管道：适合流式数据传输
信号：适合事件通知和简单控制
共享内存：适合高性能大数据传输
消息队列：适合结构化消息传递
信号量：适合进程同步和资源保护

在实际系统编程中，通常需要组合多种IPC机制来满足复杂需求。理解各种IPC机制的特点和使用场景，能够帮助开发者设计出高效可靠的进程间通信方案。

219 次浏览

6 次