正文

Linux下轻松掌握进程通信技巧，四种框架深度解析及实战案例

/0 浏览量
0331

引言

在Linux操作系统中，进程通信是程序间交互的基础。掌握进程通信的技巧对于开发高性能、高并发的应用程序至关重要。本文将深入解析四种常见的Linux进程通信框架：管道（Pipe）、信号（Signal）、共享内存（Shared Memory）和消息队列（Message Queue），并通过实战案例帮助读者更好地理解和应用这些技术。

一、管道（Pipe）

1.1 概述

管道是一种简单的进程间通信机制，允许一个进程向另一个进程传递数据。在Linux中，管道通常通过pipe()系统调用创建。

1.2 代码示例

#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]); // 关闭读端
        char *message = "Hello, parent!";
        write(pipefd[1], message, strlen(message));
        close(pipefd[1]); // 关闭写端
    } else { // 父进程
        close(pipefd[1]); // 关闭写端
        char buffer[100];
        read(pipefd[0], buffer, sizeof(buffer));
        printf("Received: %s\n", buffer);
        close(pipefd[0]); // 关闭读端
    }

    return 0;
}

1.3 实战案例

在父进程中，通过管道向子进程发送一条消息，子进程接收并打印该消息。

二、信号（Signal）

2.1 概述

信号是Linux中进程间通信的一种方式，用于通知进程发生了某种事件。信号通过kill()系统调用发送。

2.2 代码示例

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

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

int main() {
    signal(SIGINT, signal_handler);
    printf("Waiting for signal...\n");
    pause(); // 阻塞等待信号
    return 0;
}

2.3 实战案例

程序在接收到SIGINT信号（通常由Ctrl+C触发）时，会打印出接收到的信号编号。

三、共享内存（Shared Memory）

3.1 概述

共享内存是一种高效的进程间通信机制，允许多个进程访问同一块内存区域。

3.2 代码示例

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

int main() {
    key_t key = ftok("shmfile", 65);
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
    char *shm = shmat(shmid, (void *)0, 0);
    int *num = (int *)shm;

    *num = 1;
    printf("Process %d: %d\n", getpid(), *num);
    sleep(1);
    *num = 2;
    printf("Process %d: %d\n", getpid(), *num);

    shmdt(shm);
    shmctl(shmid, IPC_RMID, NULL);
    return 0;
}

3.3 实战案例

两个进程共享同一块内存区域，其中一个进程修改内存中的值，另一个进程读取并打印该值。

四、消息队列（Message Queue）

4.1 概述

消息队列是一种进程间通信机制，允许进程通过消息传递数据。消息队列通过msgget()、msgsend()和msgrcv()系统调用操作。

4.2 代码示例

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

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

int main() {
    key_t key = ftok("msgqueuefile", 65);
    int msgid = msgget(key, 0666 | IPC_CREAT);
    struct message msg;

    msg.msg_type = 1;
    snprintf(msg.msg_text, sizeof(msg.msg_text), "Hello, message queue!");

    if (msgsnd(msgid, &msg, sizeof(msg.msg_text), 0) == -1) {
        perror("msgsnd");
        return 1;
    }

    msg.msg_type = 2;
    if (msgrcv(msgid, &msg, sizeof(msg.msg_text), 1, 0) == -1) {
        perror("msgrcv");
        return 1;
    }

    printf("Received: %s\n", msg.msg_text);
    msgctl(msgid, IPC_RMID, NULL);
    return 0;
}

4.3 实战案例

一个进程向消息队列发送一条消息，另一个进程从消息队列接收并打印该消息。

总结

本文深入解析了Linux下的四种进程通信框架：管道、信号、共享内存和消息队列，并通过实战案例帮助读者更好地理解和应用这些技术。掌握这些技巧对于开发高性能、高并发的应用程序具有重要意义。

-- 展开阅读全文 --