进程间的通信机制

进程间的通信机制

进程间通信（IPC）是指在操作系统中，不同进程之间进行数据交换和共享信息的机制。Linux 内核提供了多种进程间通信的方式，常见的包括管道、消息队列、共享内存、信号量和 Socket。

1. 管道

管道是一种最简单的进程间通信方式，它分为匿名管道和命名管道。

• 匿名管道：用于具有亲缘关系的父子进程之间的通信。数据在管道中是无格式的流，并且通信是单向的。创建匿名管道时，可以使用pipe()系统调用。以下是一个匿名管道的示例：

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

int main() {
    int fd[2];
    char buffer[255];

    // 创建管道
    pipe(fd);

    if (fork() == 0) {
        // 子进程从管道中读取数据
        read(fd[0], buffer, sizeof(buffer));
        printf("子进程收到的消息：%s\n", buffer);
    } else {
        // 父进程向管道中写入数据
        write(fd[1], "Hello, child process!", sizeof("Hello, child process!"));
    }

    return 0;
}

• 命名管道：突破了亲缘关系的进程通信限制，允许不同进程之间进行通信。命名管道在文件系统中创建一个特殊的设备文件，进程通过该设备文件进行通信。命名管道可以使用mkfifo()函数创建。以下是一个命名管道的示例：

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

int main() {
    int fd;
    char buffer[255];

    // 创建命名管道
    mkfifo("/tmp/myfifo", 0666);

    // 打开命名管道
    fd = open("/tmp/myfifo", O_RDONLY);

    // 从管道中读取数据
    read(fd, buffer, sizeof(buffer));
    printf("收到的消息：%s\n", buffer);

    // 关闭管道
    close(fd);
    
    return 0;
}

2. 消息队列

消息队列允许进程之间传递格式化的消息，并且可以实现非亲缘关系进程之间的通信。消息队列将消息保存在内核中的消息链表中，发送方和接收方需要使用相同的消息类型来保证正确的数据传输。以下是一个使用消息队列进行通信的示例：

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

struct message {
    long type;
    char text[100];
};

int main() {
    key_t key;
    int msgid;
    struct message msg;

    // 创建消息队列
    key = ftok("file", 65); // 使用文件和字符 'A' 生成唯一的键值
    msgid = msgget(key, 0666 | IPC_CREAT);

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

    // 接收消息
    msgrcv(msgid, &msg, sizeof(msg), 1, 0);
    printf("收到的消息：%s\n", msg.text);

    // 删除消息队列
    msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

3. 共享内存

共享内存允许多个进程访问同一块内存区域，实现高效的数据共享。由于共享内存不会涉及拷贝操作，因此速度较快。但需要注意的是，进程需要使用信号量等机制来保护共享资源的访问，以避免数据错乱。以下是一个使用共享内存进行通信的示例：

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

int main() {
    key_t key;
    int shmid;
    char *data;

    // 创建共享内存
    key = ftok("file", 65); // 使用文件和字符 'A' 生成唯一的键值
    shmid = shmget(key, 1024, 0666 | IPC_CREAT);

    // 连接共享内存
    data = (char*)shmat(shmid, NULL, 0);

    // 在共享内存中写入数据
    sprintf(data, "Hello, shared memory!");

    // 从共享内存中读取数据
    printf("收到的消息：%s\n", data);

    // 解除共享内存连接
    shmdt(data);

    // 删除共享内存
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

4. 信号量

信号量用于保护共享资源的访问，确保同一时间只有一个进程可以访问该资源。信号量还可以实现进程间的同步。以下是一个使用信号量进行进程间同步的示例：

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

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

int main() {
    key_t key;
    int semid;
    struct sembuf sb;
    union semun arg;

    // 创建信号量集合
    key = ftok("file", 65); // 使用文件和字符 'A' 生成唯一的键值
    semid = semget(key, 1, 0666 | IPC_CREAT);

    // 初始化信号量
    arg.val = 1; // 初始值为 1，表示资源可用
    semctl(semid, 0, SETVAL, arg);

    if (fork() == 0) {
        // 子进程等待信号量
        sb.sem_num = 0;
        sb.sem_op = -1; // 获取资源
        sb.sem_flg = 0;
        semop(semid, &sb, 1);

        // 执行临界区代码
        printf("子进程执行临界区代码\n");

        // 释放信号量
        sb.sem_op = 1; // 释放资源
        semop(semid, &sb, 1);
    } else {
        // 父进程等待信号量
        sb.sem_num = 0;
        sb.sem_op = -1; // 获取资源
        sb.sem_flg = 0;
        semop(semid, &sb, 1);

        // 执行临界区代码
        printf("父进程执行临界区代码\n");

        // 释放信号量
        sb.sem_op = 1; // 释放资源
        semop(semid, &sb, 1);
    }

    // 删除信号量集合
    semctl(semid, 0, IPC_RMID, arg);

    return 0;
}

5. Socket

Socket 是一种网络编程接口，它不仅用于不同主机之间的进程通信，还可以用于本地主机进程间的通信。Socket 提供了基于 TCP 和 UDP 协议的通信方式。以下是一个使用 Socket 进行本地进程间通信的示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

int main() {
    int sockfd;
    struct sockaddr_un server_addr, client_addr;
    char buffer[255];

    // 创建 Socket
    sockfd = socket(AF_UNIX, SOCK_STREAM, 0);

    // 绑定地址
    server_addr.sun_family = AF_UNIX;
    strcpy(server_addr.sun_path, "/tmp/socket");
    bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));

    // 监听连接
    listen(sockfd, 5);

    // 接受连接
    socklen_t len = sizeof(client_addr);
    int clientfd = accept(sockfd, (struct sockaddr*)&client_addr, &len);

    // 读取数据
    read(clientfd, buffer, sizeof(buffer));
    printf("收到的消息：%s\n", buffer);

    // 发送数据
    write(clientfd, "Hello, client process!", sizeof("Hello, client process!"));

    // 关闭连接
    close(clientfd);
    close(sockfd);

    // 删除 Socket 文件
    unlink("/tmp/socket");

    return 0;
}

这些进程间通信机制提供了不同的方式来满足进程间数据交换和共享的需求。根据具体的场景和要求，选择合适的通信机制能够更好地满足应用程序的需求。

笔记来源AI