正文

揭秘Linux下进程通信的五大实用框架，轻松实现跨进程数据交互

/0 浏览量
0331

在Linux操作系统中，进程通信是操作系统核心功能之一。它允许不同进程之间进行数据交换和同步。了解并掌握进程通信的框架对于系统开发、网络编程以及分布式系统构建都至关重要。下面，我将详细介绍Linux下五大实用的进程通信框架，帮助您轻松实现跨进程数据交互。

1. 管道（Pipes）

管道是Linux中最基本的进程通信机制之一。它允许一个进程向另一个进程传递数据。管道有两种类型：无名管道和命名管道。

无名管道

无名管道只能在具有亲缘关系的进程间使用，即父子进程或者兄弟进程。它的创建和使用非常简单，如下所示：

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

int main() {
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

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

    return 0;
}

命名管道（FIFO）

命名管道是一种特殊的文件，它可以在任意两个进程间进行通信。创建命名管道使用mkfifo函数，如下所示：

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

int main() {
    if (mkfifo("fifo", 0666) == -1) {
        perror("mkfifo");
        return 1;
    }

    // ... 读写操作 ...

    unlink("fifo"); // 删除命名管道

    return 0;
}

2. 套接字（Sockets）

套接字是Linux下实现网络通信的基石。它允许不同主机上的进程进行通信。套接字分为流式套接字和数据报套接字。

流式套接字

流式套接字提供可靠的、面向连接的通信服务。以下是一个简单的TCP客户端和服务器示例：

// 服务器端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);

    // 创建socket文件描述符
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 强制绑定到端口
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);

    // 绑定socket到端口
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address))<0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    // 监听socket
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    // 接受客户端连接
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen))<0) {
        perror("accept");
        exit(EXIT_FAILURE);
    }

    // 读写操作 ...

    return 0;
}

// 客户端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int sock = 0, valread;
    struct sockaddr_in serv_addr;
    char buffer[1024] = {0};

    // 创建socket文件描述符
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        printf("\n Socket creation error \n");
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    // 将IP地址转换为二进制形式
    if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0) {
        printf("\nInvalid address/ Address not supported \n");
        return -1;
    }

    // 连接到服务器
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        printf("\nConnection Failed \n");
        return -1;
    }

    // 读写操作 ...

    return 0;
}

数据报套接字

数据报套接字提供无连接、不可靠的通信服务。它适用于网络中的点对点通信，如UDP协议。

// UDP客户端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[1024] = {0};

    // 创建socket文件描述符
    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        printf("\n Socket creation error \n");
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    // 将IP地址转换为二进制形式
    if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0) {
        printf("\nInvalid address/ Address not supported \n");
        return -1;
    }

    // 发送数据
    sendto(sock, "Hello, UDP!", strlen("Hello, UDP!"), 0, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

    // 接收数据
    valread = read(sock, buffer, 1024);
    printf("%s\n", buffer);

    return 0;
}

// UDP服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char buffer[1024] = {0};

    // 创建socket文件描述符
    if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        printf("\n Socket creation error \n");
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    // 绑定socket到端口
    if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        printf("\nBind failed \n");
        return -1;
    }

    // 接收数据
    valread = recvfrom(sock, buffer, 1024, 0, (struct sockaddr *)&serv_addr, (socklen_t*)&addrlen);
    printf("%s\n", buffer);

    return 0;
}

3. 信号（Signals）

信号是Linux下实现进程通信的一种简单机制。它允许一个进程向另一个进程发送一个简单的消息。信号分为标准信号和实时信号。

标准信号

标准信号包括SIGINT、SIGTERM、SIGKILL等。以下是一个使用信号实现进程通信的示例：

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

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

int main() {
    signal(SIGINT, handler);
    signal(SIGTERM, handler);

    while (1) {
        printf("Process is running...\n");
        sleep(1);
    }

    return 0;
}

实时信号

实时信号包括SIGUSR1、SIGUSR2等。它们提供更灵活的进程通信机制。

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

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

int main() {
    signal(SIGUSR1, handler);
    signal(SIGUSR2, handler);

    while (1) {
        printf("Process is running...\n");
        sleep(1);
    }

    return 0;
}

4. 共享内存（Shared Memory）

共享内存允许不同进程访问同一块内存区域。它提供了一种高效的进程通信机制，适用于大量数据的传输。

#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>

int main() {
    key_t key = ftok("file", 65);
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
    char *shared_memory = shmat(shmid, NULL, 0);

    // 读写操作 ...

    shmdt(shared_memory);
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

5. 消息队列（Message Queues）

消息队列允许不同进程通过消息进行通信。它提供了一种灵活的通信机制，支持多种消息类型和优先级。

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

struct message {
    long msg_type;
    char msg_text[256];
};

int main() {
    key_t key = ftok("file", 65);
    int msgid = msgget(key, 0666 | IPC_CREAT);

    // 发送消息
    struct message msg;
    msg.msg_type = 1;
    strcpy(msg.msg_text, "Hello, message queue!");
    msgsnd(msgid, &msg, sizeof(msg.msg_text), 0);

    // 接收消息
    struct message received_msg;
    msgrcv(msgid, &received_msg, sizeof(received_msg.msg_text), 1, 0);

    printf("Received message: %s\n", received_msg.msg_text);

    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

通过以上五大实用框架，您可以在Linux下轻松实现跨进程数据交互。掌握这些框架，将有助于您在系统开发、网络编程以及分布式系统构建等方面取得更好的成果。

-- 展开阅读全文 --