Linux进程间通信：总结与实践-猿码集

1. 概述

Linux是一个多用户、多任务的操作系统，不同的进程之间需要进行通信来共享数据和协调工作。进程间通信（IPC）是实现这一目标的关键。Linux提供了多种进程间通信的机制，包括管道、信号、共享内存、消息队列和套接字等。本文将对这些机制进行总结和实践，探讨它们的应用场景和使用方法。

2. 管道

2.1 管道概述

管道是最古老的进程间通信机制之一，它是一个单向的、字节流的通道，可用于将一个进程的输出连接到另一个进程的输入。

管道可以通过使用pipe()系统调用来创建，它返回两个文件描述符，一个用于读取管道的数据，另一个用于写入管道的数据。管道的读写操作可以通过文件描述符进行，类似于对文件进行读写。


int pipe(int pipefd[2]);

2.2 管道实践

下面是一个例子，展示了如何使用管道在两个进程之间传递数据：


#include <unistd.h>
#include <stdio.h>
int main() {
    int pipefd[2];
    pid_t pid;
    // 创建管道
    if (pipe(pipefd) < 0) {
        perror("pipe");
        return -1;
    }
    // 创建子进程
    pid = fork();
    if (pid < 0) {
        perror("fork");
        return -1;
    }
    if (pid > 0) {
        // 父进程写入数据到管道
        close(pipefd[0]); // 关闭读取端
        char data[] = "Hello, child process!";
        write(pipefd[1], data, sizeof(data));
        close(pipefd[1]); // 关闭写入端
    } else {
        // 子进程从管道中读取数据
        close(pipefd[1]); // 关闭写入端
        char buffer[1024];
        read(pipefd[0], buffer, sizeof(buffer));
        printf("Received message: %s\n", buffer);
        close(pipefd[0]); // 关闭读取端
    }
    return 0;
}

在上面的例子中，父进程使用write()将数据写入管道，子进程则使用read()从管道中读取数据。通过管道，父子进程之间可以传递数据来进行通信。

3. 信号

3.1 信号概述

信号是Linux中用于进程间通信的简单且高效的机制之一。当一个进程需要与另一个进程进行通信时，它可以通过发送一个信号来通知目标进程做出相应的动作。

Linux提供了许多预定义的信号，如SIGKILL、SIGSTOP和SIGTERM等，进程可以通过调用kill()系统调用来发送信号给其他进程。


int kill(pid_t pid, int sig);

目标进程则可以通过使用signal()函数来为自己设置信号处理程序，以响应接收到的信号：


void (*signal(int sig, void (*func)(int)))(int);

3.2 信号实践

下面是一个用于捕捉SIGINT信号（当用户按下Ctrl+C时发送的信号）的示例：


#include <stdio.h>
#include <signal.h>
void sigint_handler(int signo) {
    printf("Received SIGINT signal!\n");
}
int main() {
    if (signal(SIGINT, sigint_handler) == SIG_ERR) {
        perror("signal");
        return -1;
    }
    while (1) {
        // 无限循环
    }
    return 0;
}

在上面的示例中，当用户按下Ctrl+C时，程序将打印"Received SIGINT signal!"的消息。通过捕捉信号，程序可以根据需要做出相应的处理动作。

4. 共享内存

4.1 共享内存概述

共享内存是一种高效的进程间通信机制，它允许多个进程共享同一块内存区域。这种机制可以显著提高数据传输的效率，适用于需要频繁交换大量数据的场景。

Linux提供了shmget()函数来创建共享内存段，shmat()函数来将共享内存连接到进程的地址空间，shmdt()函数来分离共享内存，shmctl()函数来控制共享内存的操作。


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);

4.2 共享内存实践

下面是一个使用共享内存进行数据传输的示例：


#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int main() {
    key_t key = ftok("/tmp/mem", 'R');
    int shmid = shmget(key, 1024, 0666|IPC_CREAT);
    char *data = (char*) shmat(shmid, (void*)0, 0);
    printf("Enter message: ");
    fgets(data, 1024, stdin);
    printf("Message written: %s\n", data);
    shmdt(data);
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

在上面的例子中，程序使用shmget()函数创建共享内存段，然后使用shmat()将共享内存连接到进程的地址空间。之后，程序可以像使用普通内存那样读写共享内存。最后，程序使用shmdt()将共享内存分离，使用shmctl()删除共享内存段。

5. 消息队列

5.1 消息队列概述

消息队列是Linux中一种可以在多个进程之间传递数据的通信机制，它提供了一种无关进程间的通信方式，进程可以通过往消息队列中写入消息来传递数据，其他进程则可以从消息队列中读取这些消息。

Linux提供了msgget()函数来创建消息队列，msgsnd()函数来向消息队列发送消息，msgrcv()函数来从消息队列接收消息，以及msgctl()函数来控制消息队列的属性。


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);

5.2 消息队列实践

下面是一个使用消息队列进行数据传输的示例：


#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct msg_buffer {
    long msg_type;
    char msg_text[1024];
};
int main() {
    key_t key = ftok("/tmp/msgq", 'R');
    int msqid = msgget(key, 0666|IPC_CREAT);
    struct msg_buffer message;
    printf("Enter message: ");
    fgets(message.msg_text, 1024, stdin);
    message.msg_type = 1;
    msgsnd(msqid, &message, sizeof(message), 0);
    printf("Message sent: %s\n", message.msg_text);
    return 0;
}

在上面的例子中，程序使用msgget()函数创建消息队列，然后使用msgsnd()函数向消息队列发送消息。消息的类型由msg_type字段指定，可以根据需要定义不同的类型。通过指定不同的类型，进程可以选择接收特定类型的消息。

6. 套接字

6.1 套接字概述

套接字是一种用于在网络上进行进程间通信的机制。Linux将其作为一种特殊的文件类型来处理，进程可以通过套接字读写数据来进行通信。

套接字可以分为流套接字（TCP）和数据报套接字（UDP）。流套接字提供可靠的、面向连接的通信，适用于传输大量数据的场景；数据报套接字提供无连接的通信，适用于一次性传输少量数据的场景。

6.2 套接字实践

下面是一个使用套接字进行本地进程间通信的示例：


#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#define PORT 8080
int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[1024] = {0};
    char *hello = "Hello from server";
    // 创建套接字
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        return -1;
    }
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);
    // 绑定地址和端口
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address))<0) {
        perror("bind failed");
        return -1;
    }
    // 监听连接
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        return -1;
    }
    // 接受客户端连接
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen))<0) {
        perror("accept");
        return -1;
    }
    // 从客户端接收数据
    read(new_socket, buffer, 1024);
    printf("Client: %s\n", buffer);
    // 向客户端发送数据
    send(new_socket, hello, strlen(hello), 0);
    printf("Hello message sent\n");
    return 0;
}

在上面的示例中，程序通过socket()函数创建一个套接字，然后使用bind()将其绑定到指定的地址和端口。之后，程序通过listen()函数监听进来的连接，使用accept()函数接受客户端的连接。当有客户端连接进来后，服务器可以通过read()来接收客户端发送的数据，通过send()向客户端发送数据。

7. 总结

本文对Linux的进程间通信机制进行了总结与实践，包括管道、信号、共享内存、消息队列和套接字等。每一种机制都有其特点和适用的场景，开发人员可以根据实际需求选择合适的通信方式。了解这些通信机制和相应的系统调用对于编写高效、可靠的多进程程序非常重要。

Linux进程间通信：总结与实践