正文

揭秘C语言实现跨进程通讯的5大实用框架，助你轻松解决复杂问题

/0 浏览量
0331

跨进程通讯（Inter-Process Communication，简称IPC）在计算机系统中扮演着重要角色，它允许不同的进程之间进行信息交换。在C语言编程中，实现IPC有多种方式，以下将详细介绍五种常用的跨进程通讯框架，帮助读者轻松解决复杂问题。

1. 管道（Pipe）

概念：管道是一种简单而强大的IPC机制，用于连接具有亲缘关系的两个进程，通常用于父进程和子进程之间的通信。

实现：

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

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

    // 创建管道
    if (pipe(pipe_fd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    // 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid > 0) {
        // 父进程
        close(pipe_fd[0]); // 关闭读端
        write(pipe_fd[1], "Hello, IPC!", 14);
        close(pipe_fd[1]);
    } else {
        // 子进程
        close(pipe_fd[1]); // 关闭写端
        char buffer[100];
        read(pipe_fd[0], buffer, sizeof(buffer) - 1);
        printf("Received: %s\n", buffer);
        close(pipe_fd[0]);
    }

    return 0;
}

2. 命名管道（FIFO）

概念：命名管道是一种持久的IPC机制，即使创建它们的进程已经终止，它仍然存在。

实现：

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

int main() {
    int fifo_fd;
    mkfifo("fifo1", 0666);

    // 父进程
    fifo_fd = open("fifo1", O_WRONLY);
    write(fifo_fd, "Hello, IPC!", 14);
    close(fifo_fd);

    // 子进程
    fifo_fd = open("fifo1", O_RDONLY);
    char buffer[100];
    read(fifo_fd, buffer, sizeof(buffer) - 1);
    printf("Received: %s\n", buffer);
    close(fifo_fd);

    unlink("fifo1");
    return 0;
}

3. 信号量（Semaphore）

概念：信号量是一种同步机制，用于协调多个进程对共享资源的访问。

实现：

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

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

int main() {
    int sem_id;
    struct sembuf sem_op;

    // 创建信号量集
    sem_id = semget(IPC_PRIVATE, 1, 0666 | IPC_CREAT);
    if (sem_id == -1) {
        perror("semget");
        exit(EXIT_FAILURE);
    }

    // 初始化信号量
    union semun arg;
    arg.val = 1;
    if (semctl(sem_id, 0, SETVAL, arg) == -1) {
        perror("semctl");
        exit(EXIT_FAILURE);
    }

    // 进程A
    sem_op.sem_num = 0;
    sem_op.sem_op = -1; // P操作
    sem_op.sem_flg = 0;
    if (semop(sem_id, &sem_op, 1) == -1) {
        perror("semop");
        exit(EXIT_FAILURE);
    }

    printf("进程A执行完毕\n");

    // 销毁信号量集
    if (semctl(sem_id, 0, IPC_RMID, arg) == -1) {
        perror("semctl");
        exit(EXIT_FAILURE);
    }

    return 0;
}

4. 共享内存（Shared Memory）

概念：共享内存允许多个进程访问同一块内存区域，实现高速的进程间通信。

实现：

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

#define SHARED_MEMORY_PATH "/shared_memory"

int main() {
    int shm_fd;
    char *shared_memory;

    // 打开共享内存对象
    shm_fd = open(SHARED_MEMORY_PATH, O_RDWR | O_CREAT, 0666);
    if (shm_fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 确保共享内存的大小为1024字节
    if (ftruncate(shm_fd, 1024) == -1) {
        perror("ftruncate");
        exit(EXIT_FAILURE);
    }

    // 映射共享内存到进程地址空间
    shared_memory = mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
    if (shared_memory == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }

    // 写入共享内存
    strcpy(shared_memory, "Hello, IPC!");

    // 等待另一个进程访问共享内存
    sleep(10);

    // 取消映射并关闭文件描述符
    munmap(shared_memory, 1024);
    close(shm_fd);

    return 0;
}

5. 消息队列（Message Queue）

概念：消息队列是一种基于消息的IPC机制，允许进程发送和接收固定大小的消息。

实现：

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

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

int main() {
    int msg_id;
    struct msgbuf msg;

    // 创建消息队列
    msg_id = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
    if (msg_id == -1) {
        perror("msgget");
        exit(EXIT_FAILURE);
    }

    // 发送消息
    msg.msg_type = 1;
    strcpy(msg.msg_text, "Hello, IPC!");
    if (msgsend(msg_id, &msg, sizeof(msg), 0) == -1) {
        perror("msgsend");
        exit(EXIT_FAILURE);
    }

    // 接收消息
    msgrcv(msg_id, &msg, sizeof(msg), 1, 0);
    printf("Received: %s\n", msg.msg_text);

    // 销毁消息队列
    if (msgctl(msg_id, IPC_RMID, NULL) == -1) {
        perror("msgctl");
        exit(EXIT_FAILURE);
    }

    return 0;
}

总结：

以上介绍了五种常用的C语言实现跨进程通讯的框架，包括管道、命名管道、信号量、共享内存和消息队列。通过了解这些框架的工作原理和实现方法，可以有效地解决实际编程中遇到的复杂问题。

-- 展开阅读全文 --