Linux 进程间通讯

Linux IPC 方式

在Linux系统中，进程间通信（IPC）是多个运行中的程序或进程之间交换数据和信息的关键机制。Linux提供了多种IPC机制，每种机制都有其特定的用途和优势。以下是Linux上主要的IPC通信方式：

管道（Pipes）
- 管道是Linux中最古老的IPC机制之一，它允许数据从一个进程（生产者）流向另一个进程（消费者）。管道是半双工的，即数据只能在一个方向上传输。
- 无名管道：仅在具有亲缘关系的进程（如父进程和子进程）之间可用，一旦创建了管道，它就与创建它的进程相关联。
- 命名管道（FIFO）：可以在没有亲缘关系的进程之间使用，它们是文件系统中的特殊文件，可以跨启动会话使用。
消息队列（Message Queues）
- 消息队列允许进程之间传递结构化的消息，每个消息都有一个类型，这使得消息的过滤成为可能。
- 消息队列是系统V IPC的一部分，可以在多个进程中使用，即使进程重启后仍然存在。
信号量（Semaphores）
- 信号量用于控制对共享资源的访问，避免竞态条件。它们可以是二进制（只有0和1的状态）或计数信号量（可以有多个单位）。
- 信号量同样属于系统V IPC的一部分，可以跨进程使用，用于同步进程间的操作。
共享内存（Shared Memory）
- 共享内存允许多个进程直接访问同一块内存区域，这是最快的IPC机制，因为数据不需要复制。
- 使用共享内存时，通常还需要信号量或互斥锁来防止多个进程同时修改同一数据。
信号（Signals）
- 信号是软件中断，可以由硬件事件、软件异常或另一个进程发送给进程。它们主要用于通知进程发生了某些事件。
- 信号本身并不携带大量数据，但是可以触发进程执行特定的操作。
套接字（Sockets）
- 套接字提供了进程间通信的网络接口，不仅限于本地进程间通信，还可以用于网络通信。
- 包括流式套接字（SOCK_STREAM，类似TCP）和数据报套接字（SOCK_DGRAM，类似UDP）。
流（Streams）
- 流类似于管道，但它们提供了更复杂的通信机制，支持错误处理、流控制和多路复用。
内存映射文件（Memory-Mapped Files）
- 虽然严格来说这不是传统的IPC机制，但通过将文件映射到内存中，进程可以像访问内存一样访问文件，从而实现进程间的数据共享。

选择IPC机制时，应考虑通信的需求（如速度、可靠性、复杂性、数据大小等），以及进程之间的关系（如是否在同一台机器上，是否有亲缘关系等）。例如，对于需要高速数据传输的场景，共享内存可能是最佳选择，而如果需要在网络上的多个机器之间通信，则应使用套接字。

几种常用的方式举例说明

1. 管道（Pipes）：

匿名管道（Anonymous Pipes） ：只能用于有亲缘关系的进程之间（如父子进程）。通过pipe()系统调用创建，数据以字节流的形式在进程之间传输。

示例：

int fd[2];
pipe(fd);
if (fork() == 0) {
    // 子进程
    close(fd[1]);
    char buf[100];
    read(fd[0], buf, sizeof(buf));
    printf("Child read: %s\n", buf);
    close(fd[0]);
} else {
    // 父进程
    close(fd[0]);
    write(fd[1], "Hello from parent", 17);
    close(fd[1]);
}

命名管道（Named Pipes/FIFOs） ：可以用于没有亲缘关系的进程之间。通过mkfifo()系统调用创建。

示例：

mkfifo("/tmp/myfifo", 0666);
if (fork() == 0) {
    // 子进程
    int fd = open("/tmp/myfifo", O_RDONLY);
    char buf[100];
    read(fd, buf, sizeof(buf));
    printf("Child read: %s\n", buf);
    close(fd);
} else {
    // 父进程
    int fd = open("/tmp/myfifo", O_WRONLY);
    write(fd, "Hello from parent", 17);
    close(fd);
    wait(NULL); // 等待子进程结束
    unlink("/tmp/myfifo"); // 删除FIFO文件
}

2. 消息队列（Message Queues）：

提供了一种基于消息的通信方式，允许发送和接收带类型的消息。通过msgget()、msgsnd()和msgrcv()系统调用进行操作。

示例：

key_t key = ftok("somefile", 65);
int msgid = msgget(key, 0666 | IPC_CREAT);
struct msg_buffer {
    long msg_type;
    char msg_text[100];
} message;

if (fork() == 0) {
    // 子进程
    message.msg_type = 1;
    msgrcv(msgid, &message, sizeof(message.msg_text), 1, 0);
    printf("Child received: %s\n", message.msg_text);
} else {
    // 父进程
    message.msg_type = 1;
    strcpy(message.msg_text, "Hello from parent");
    msgsnd(msgid, &message, sizeof(message.msg_text), 0);
    wait(NULL); // 等待子进程结束
    msgctl(msgid, IPC_RMID, NULL); // 删除消息队列
}

3. 共享内存（Shared Memory）：

允许多个进程直接访问同一块内存区域，通过shmget()、shmat()和shmdt()系统调用进行操作，通常需要配合信号量或互斥锁来控制访问。

示例：

key_t key = ftok("somefile", 65);
int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
char *str = (char*) shmat(shmid, NULL, 0);

if (fork() == 0) {
    // 子进程
    sleep(1); // 确保父进程先写入
    printf("Child read: %s\n", str);
    shmdt(str);
} else {
    // 父进程
    strcpy(str, "Hello from parent");
    wait(NULL); // 等待子进程结束
    shmdt(str);
    shmctl(shmid, IPC_RMID, NULL); // 删除共享内存
}

4. 信号量（Semaphores）：

用于控制对共享资源的访问，通过semget()、semop()和semctl()系统调用进行操作。

示例：

key_t key = ftok("somefile", 65);
int semid = semget(key, 1, 0666 | IPC_CREAT);
semctl(semid, 0, SETVAL, 1); // 初始化信号量为1
struct sembuf sb = {0, -1, 0}; // P操作

if (fork() == 0) {
    // 子进程
    semop(semid, &sb, 1); // P操作
    printf("Child in critical section\n");
    sleep(2);
    sb.sem_op = 1; // V操作
    semop(semid, &sb, 1);
} else {
    // 父进程
    semop(semid, &sb, 1); // P操作
    printf("Parent in critical section\n");
    sleep(2);
    sb.sem_op = 1; // V操作
    semop(semid, &sb, 1);
    wait(NULL); // 等待子进程结束
    semctl(semid, 0, IPC_RMID); // 删除信号量
}

5. 套接字（Sockets）：

适用于网络通信，也可以用于同一台机器上的进程间通信，支持面向连接的TCP和无连接的UDP协议。

示例（Unix域套接字）：

int sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
struct sockaddr_un addr = {0};
addr.sun_family = AF_UNIX;
strcpy(addr.sun_path, "/tmp/mysocket");

if (fork() == 0) {
    // 子进程
    sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    connect(sockfd, (struct sockaddr*)&addr, sizeof(addr));
    char buf[100];
    read(sockfd, buf, sizeof(buf));
    printf("Child read: %s\n", buf);
    close(sockfd);
} else {
    // 父进程
    bind(sockfd, (struct sockaddr*)&addr, sizeof(addr));
    listen(sockfd, 5);
    int connfd = accept(sockfd, NULL, NULL);
    write(connfd, "Hello from parent", 17);
    close(connfd);
    close(sockfd);
    wait(NULL); // 等待子进程结束
    unlink("/tmp/mysocket"); // 删除套接字文件
}

这些IPC机制在实际开发中各有其适用场景，选择适合的方式可以有效地实现进程间的通信和数据共享。