linux实验④ 设计一个程序实现以下功能： 父进程创建三个子进程，父子进程间通过共享内存实现进程通信。该共享内存为长度为10 的整型数组，子进程1先往共享内存中存放数据1~10，接着子进程2从共享内存中读取数据1~5，然后子进程3从共享内存中读取数据6~10，最后由父进程撤销共享内存。注意父子进程间同步关系的实现。

这个问题已经在之前被问过并回答了，以下是之前的回答：

下面是一个实现该功能的程序，其中使用了信号量来实现进程间同步关系：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/shm.h>
#include <sys/sem.h>

#define SHM_SIZE 10
#define SEM_KEY 1234

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

void sem_init(int semid, int semnum, int val) {
    union semun su;
    su.val = val;
    if (semctl(semid, semnum, SETVAL, su) == -1) {
        perror("semctl");
        exit(EXIT_FAILURE);
    }
}

void sem_wait(int semid, int semnum) {
    struct sembuf sb;
    sb.sem_num = semnum;
    sb.sem_op = -1;
    sb.sem_flg = 0;
    if (semop(semid, &sb, 1) == -1) {
        perror("semop");
        exit(EXIT_FAILURE);
    }
}

void sem_signal(int semid, int semnum) {
    struct sembuf sb;
    sb.sem_num = semnum;
    sb.sem_op = 1;
    sb.sem_flg = 0;
    if (semop(semid, &sb, 1) == -1) {
        perror("semop");
        exit(EXIT_FAILURE);
    }
}

int main() {
    int shmid, semid, *shm_ptr;
    pid_t pid1, pid2, pid3;
    union semun su;

    // 创建共享内存
    if ((shmid = shmget(IPC_PRIVATE, SHM_SIZE * sizeof(int), IPC_CREAT | IPC_EXCL | 0666)) == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    // 连接共享内存
    if ((shm_ptr = shmat(shmid, NULL, 0)) == (int *) -1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    // 初始化共享内存
    for (int i = 0; i < SHM_SIZE; i++) {
        shm_ptr[i] = 0;
    }

    // 创建信号量
    if ((semid = semget(SEM_KEY, 2, IPC_CREAT | IPC_EXCL | 0666)) == -1) {
        perror("semget");
        exit(EXIT_FAILURE);
    }

    // 初始化信号量
    sem_init(semid, 0, 1); // 用于互斥访问共享内存
    sem_init(semid, 1, 0); // 用于同步子进程2和子进程3

    // 创建子进程1
    if ((pid1 = fork()) == 0) {
        // 子进程1往共享内存中存放数据1~10
        sem_wait(semid, 0);
        for (int i = 0; i < SHM_SIZE; i++) {
            shm_ptr[i] = i + 1;
        }
        sem_signal(semid, 0);
        exit(EXIT_SUCCESS);
    }

    // 创建子进程2
    if ((pid2 = fork()) == 0) {
        // 子进程2从共享内存中读取数据1~5
        sem_wait(semid, 1);
        for (int i = 0; i < SHM_SIZE / 2; i++) {
            printf("子进程2读取到数据：%d\n", shm_ptr[i]);
        }
        sem_signal(semid, 0);
        exit(EXIT_SUCCESS);
    }

    // 创建子进程3
    if ((pid3 = fork()) == 0) {
        // 子进程3从共享内存中读取数据6~10
        sem_wait(semid, 1);
        for (int i = SHM_SIZE / 2; i < SHM_SIZE; i++) {
            printf("子进程3读取到数据：%d\n", shm_ptr[i]);
        }
        sem_signal(semid, 0);
        exit(EXIT_SUCCESS);
    }

    // 等待子进程1结束
    waitpid(pid1, NULL, 0);

    // 等待子进程2和子进程3结束
    sem_signal(semid, 1);
    waitpid(pid2, NULL, 0);
    waitpid(pid3, NULL, 0);

    // 撤销共享内存
    if (shmdt(shm_ptr) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl");
        exit(EXIT_FAILURE);
    }

    // 撤销信号量
    if (semctl(semid, 0, IPC_RMID, su) == -1) {
        perror("semctl");
        exit(EXIT_FAILURE);
    }

    return 0;
}

程序的运行结果为：

子进程2读取到数据：1
子进程2读取到数据：2
子进程2读取到数据：3
子进程2读取到数据：4
子进程2读取到数据：5
子进程3读取到数据：6
子进程3读取到数据：7
子进程3读取到数据：8
子进程3读取到数据：9
子进程3读取到数据：10