Linux 进程间通讯

Linux IPC 方式

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

1. 管道（Pipes）

   • 管道是Linux中最古老的IPC机制之一，它允许数据从一个进程（生产者）流向另一个进程（消费者）。管道是半双工的，即数据只能在一个方向上传输。
   • 无名管道：仅在具有亲缘关系的进程（如父进程和子进程）之间可用，一旦创建了管道，它就与创建它的进程相关联。
   • 命名管道（FIFO）：可以在没有亲缘关系的进程之间使用，它们是文件系统中的特殊文件，可以跨启动会话使用。

2. 消息队列（Message Queues）

   • 消息队列允许进程之间传递结构化的消息，每个消息都有一个类型，这使得消息的过滤成为可能。
   • 消息队列是系统V IPC的一部分，可以在多个进程中使用，即使进程重启后仍然存在。

3. 信号量（Semaphores）

   • 信号量用于控制对共享资源的访问，避免竞态条件。它们可以是二进制（只有0和1的状态）或计数信号量（可以有多个单位）。
   • 信号量同样属于系统V IPC的一部分，可以跨进程使用，用于同步进程间的操作。

4. 共享内存（Shared Memory）

   • 共享内存允许多个进程直接访问同一块内存区域，这是最快的IPC机制，因为数据不需要复制。
   • 使用共享内存时，通常还需要信号量或互斥锁来防止多个进程同时修改同一数据。

5. 信号（Signals）

   • 信号是软件中断，可以由硬件事件、软件异常或另一个进程发送给进程。它们主要用于通知进程发生了某些事件。
   • 信号本身并不携带大量数据，但是可以触发进程执行特定的操作。

6. 套接字（Sockets）

   • 套接字提供了进程间通信的网络接口，不仅限于本地进程间通信，还可以用于网络通信。
   • 包括流式套接字（SOCK_STREAM，类似TCP）和数据报套接字（SOCK_DGRAM，类似UDP）。

7. 流（Streams）

   • 流类似于管道，但它们提供了更复杂的通信机制，支持错误处理、流控制和多路复用。

8. 内存映射文件（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机制在实际开发中各有其适用场景，选择适合的方式可以有效地实现进程间的通信和数据共享。