Linux进程间通信实时探索-猿码集

1. Linux进程间通信概述

在现代操作系统中，进程间通信 (IPC) 扮演了重要的角色，它允许不同的进程之间共享信息和协同工作。Linux 提供了多种进程间通信的机制，如管道、信号、共享内存、消息队列等。

2. 管道（Pipe）

管道是进程间通信的一种基本形式，它可以用于父子进程之间或者具有一定关系的进程之间进行通信。

2.1 创建管道

为了创建管道，可以调用pipe()函数。

int pipe(int pipefd[2]);

该函数的参数pipefd是一个整型数组，pipefd[0]用于从管道读取数据，pipefd[1]用于向管道写入数据。如果成功创建管道，pipe()函数会返回0，否则返回-1。

2.2 管道通信示例

下面是一个简单的父子进程间使用管道进行通信的示例：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main() {
    int pipefd[2];
    pid_t pid;
    char buffer[30];
    // 创建管道
    if (pipe(pipefd) == -1) {
        perror("pipe");
        return 1;
    }
    // 创建子进程
    pid = fork();
    if (pid == 0) {
        // 子进程从管道中读取数据
        close(pipefd[1]);
        read(pipefd[0], buffer, sizeof(buffer));
        printf("子进程收到的消息：%s\n", buffer);
        close(pipefd[0]);
    } else if (pid > 0) {
        // 父进程向管道中写入数据
        close(pipefd[0]);
        write(pipefd[1], "Hello, pipe!", 13);
        close(pipefd[1]);
    } else {
        perror("fork");
        return 1;
    }
    return 0;
}

上述示例中，父进程使用write()函数向管道写入了字符串"Hello, pipe!"，而子进程使用read()函数从管道中读取数据并打印出来。

3. 信号（Signal）

信号是一种异步通信机制，它用于通知进程发生了某个特定的事件。Linux 提供了很多种信号，如 SIGINT（中断信号）、SIGTERM（终止信号）等。

3.1 发送信号

要发送信号，可以使用kill()函数。

int kill(pid_t pid, int sig);

其中，pid是要发送信号的进程的进程ID，sig是要发送的信号的编号。如果成功发送信号，kill()函数会返回0，否则返回-1。

3.2 接收信号

在接收信号时，可以使用一个信号处理函数来处理对应的信号。

void signal_handler(int sig) {
    printf("Received signal: %d\n", sig);
}
int main() {
    signal(SIGINT, signal_handler);
    while (1) {
        // 主循环
    }
    return 0;
}

上述示例中，signal()函数用于指定当收到SIGINT信号时调用signal_handler()函数进行处理。

4. 共享内存（Shared Memory）

共享内存是一种允许不同进程之间共享数据的机制。它比其他进程间通信机制更高效，因为多个进程可以直接访问同一块物理内存。

4.1 创建共享内存

要创建共享内存，可以使用shmget()函数。

int shmget(key_t key, size_t size, int shmflg);

其中，key是共享内存的键值，size是共享内存的大小，shmflg是共享内存的选项和权限。如果成功创建共享内存，shmget()函数会返回共享内存的标识符，否则返回-1。

4.2 附加共享内存

附加共享内存后，可以使用shmat()函数将共享内存关联到进程的地址空间。

void *shmat(int shmid, const void *shmaddr, int shmflg);

其中，shmid是共享内存的标识符，shmaddr是指定共享内存的地址，shmflg是附加选项。如果附加共享内存成功，shmat()函数会返回共享内存的地址，否则返回-1。

4.3 共享内存通信示例

下面是一个简单的父子进程通过共享内存进行通信的示例：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int main() {
    int shmid;
    pid_t pid;
    char *shared_memory;
    // 创建共享内存
    shmid = shmget(IPC_PRIVATE, 1024, IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        return 1;
    }
    // 创建子进程
    pid = fork();
    if (pid == 0) {
        // 子进程附加共享内存，读取数据
        shared_memory = (char *)shmat(shmid, NULL, 0);
        printf("子进程收到的消息：%s\n", shared_memory);
        // 解除共享内存的关联
        shmdt(shared_memory);
    } else if (pid > 0) {
        // 父进程附加共享内存，写入数据
        shared_memory = (char *)shmat(shmid, NULL, 0);
        sprintf(shared_memory, "Hello, shared memory!");
        // 等待子进程结束
        wait(NULL);
        // 解除共享内存的关联，并删除共享内存
        shmdt(shared_memory);
        shmctl(shmid, IPC_RMID, NULL);
    } else {
        perror("fork");
        return 1;
    }
    return 0;
}

上述示例中，父进程使用shmget()函数创建了一块大小为1024字节的共享内存，并使用shmat()函数附加共享内存，并写入了字符串"Hello, shared memory!"。而子进程也使用shmat()函数附加共享内存，并读取到了父进程写入的数据。

5. 消息队列（Message Queue）

消息队列是一种进程间通信的机制，它允许一个进程向另一个进程发送和接收消息。

5.1 创建消息队列

要创建消息队列，可以使用msgget()函数。

int msgget(key_t key, int msgflg);

其中，key是消息队列的键值，msgflg是消息队列的选项和权限。如果成功创建消息队列，msgget()函数会返回消息队列的标识符，否则返回-1。

5.2 发送消息

要发送消息，可以使用msgsnd()函数。

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

其中，msqid是消息队列的标识符，msgp是指向要发送的消息的指针，msgsz是消息的大小，msgflg是发送选项。如果成功发送消息，msgsnd()函数会返回0，否则返回-1。

5.3 接收消息

要接收消息，可以使用msgrcv()函数。

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

其中，msqid是消息队列的标识符，msgp是指向接收消息的缓冲区的指针，msgsz是接收消息的大小，msgtyp是接收消息的类型，msgflg是接收选项。如果成功接收消息，msgrcv()函数会返回消息的大小，否则返回-1。

5.4 消息队列通信示例

下面是一个简单的父子进程通过消息队列进行通信的示例：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
struct message {
    long mtype;
    char mtext[100];
};
int main() {
    int msqid;
    pid_t pid;
    struct message msg;
    // 创建消息队列
    msqid = msgget(IPC_PRIVATE, IPC_CREAT | 0666);
    if (msqid == -1) {
        perror("msgget");
        return 1;
    }
    // 创建子进程
    pid = fork();
    if (pid == 0) {
        // 子进程接收消息
        msgrcv(msqid, &msg, sizeof(msg.mtext), 1, 0);
        printf("子进程收到的消息：%s\n", msg.mtext);
    } else if (pid > 0) {
        // 父进程发送消息
        msg.mtype = 1;
        sprintf(msg.mtext, "Hello, message queue!");
        msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
        // 等待子进程结束
        wait(NULL);
        // 删除消息队列
        msgctl(msqid, IPC_RMID, NULL);
    } else {
        perror("fork");
        return 1;
    }
    return 0;
}

上述示例中，父进程使用msgget()函数创建了一个消息队列，并使用msgsnd()函数向消息队列发送了一条消息，消息类型为1。而子进程使用msgrcv()函数从消息队列接收到了父进程发送的消息。

结论

通过本文的介绍，我们对Linux进程间通信的几种常用机制有了更深入的了解。管道、信号、共享内存和消息队列都可以在不同进程之间传递信息，但每种机制都有不同的特点和适用范围。因此，根据具体的需求选择合适的进程间通信方式是非常重要的。

Linux进程间通信实时探索