进程间通信如何实现搭配代码并注释

进程间通信是指不同进程之间进行数据交换、资源共享和通信的过程。在操作系统中，进程间通信通常包括管道、消息队列、共享内存和套接字等方式。

以下是一个使用共享内存和信号量实现进程间通信的示例代码，并注释解释了每一步的操作：

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

#define SHMSIZE 1024 // 共享内存的大小

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

int main() {
    int shmid, semid;
    char *shm;
    key_t key;
    union semun arg;
    struct sembuf sb;

    // 创建一个共享内存段
    key = ftok(".", 's');
    shmid = shmget(key, SHMSIZE, IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(1);
    }

    // 连接共享内存到当前进程的地址空间
    shm = shmat(shmid, NULL, 0);
    if (shm == (char *) -1) {
        perror("shmat");
        exit(1);
    }

    // 获取一个信号量
    semid = semget(key, 1, IPC_CREAT | 0666);
    if (semid == -1) {
        perror("semget");
        exit(1);
    }

    // 初始化信号量
    arg.val = 1;
    if (semctl(semid, 0, SETVAL, arg) == -1) {
        perror("semctl");
        exit(1);
    }

    // 使用共享内存和信号量进行进程间通信
    pid_t pid;
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(1);
    } else if (pid == 0) {
        // 子进程
        sb.sem_num = 0;
        sb.sem_op = -1; // P操作，获取信号量
        sb.sem_flg = SEM_UNDO;
        semop(semid, &sb, 1);

        printf("子进程写入数据：");
        scanf("%s", shm);

        sb.sem_num = 0;
        sb.sem_op = 1; // V操作，释放信号量
        sb.sem_flg = SEM_UNDO;
        semop(semid, &sb, 1);

        exit(0);
    } else {
        // 父进程
        sb.sem_num = 0;
        sb.sem_op = -1; // P操作，获取信号量
        sb.sem_flg = SEM_UNDO;
        semop(semid, &sb, 1);

        printf("父进程读取数据：%s\n", shm);

        sb.sem_num = 0;
        sb.sem_op = 1; // V操作，释放信号量
        sb.sem_flg = SEM_UNDO;
        semop(semid, &sb, 1);

        // 删除共享内存和信号量
        shmdt(shm);
        shmctl(shmid, IPC_RMID, NULL);
        semctl(semid, 0, IPC_RMID, arg);
    }

    return 0;
}

注释解释：

1. 定义了一个 `union semun` 结构体，用于在信号量控制函数 `semctl()` 中传递参数。
2. 定义了一个结构体 `struct sembuf`，用于在信号量控制函数 `semop()` 中传递参数。
3. 创建一个共享内存段，并指定大小为 `SHMSIZE`。
4. 将共享内存连接到当前进程的地址空间。
5. 获取一个信号量。
6. 初始化信号量的值为 1。
7. 创建一个子进程。
8. 子进程使用 `semop()` 函数获取信号量，执行写操作，然后释放信号量。
9. 父进程使用 `semop()` 函数获取信号量，执行读操作，然后释放信号量。
10. 删除共享内存和信号量。