由父进程创建一个管道，然后再创建3个子进程，并由这三个子进程用管道与父进程之间进行通信：子进程发送信息，父进程等三个子进程全部发完消息后再接收信息。通信的具体内容可根据自己的需要随意设计，要求能够实验阻塞型读写过程的各种情况，并要求实现进程间对管道的互斥访问。运行程序，观察各种情况下，进程实际读写的字节数以及进程阻塞唤醒情况。

好的，这是一个进程间通信的问题，需要使用管道和进程同步。我可以提供一些思路和代码片段。

首先，父进程需要创建一个无名管道（匿名管道），并创建三个子进程。每个子进程都需要向管道中写入一些数据，然后等待其他子进程完成写入操作。父进程需要等待所有子进程完成写入操作后，再从管道中读取数据。

可以使用fork函数创建子进程，使用pipe函数创建管道。代码如下：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <errno.h>

#define BUF_SIZE 1024

int main() {
    int pipefd[2];
    pid_t pid;

    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    for (int i = 0; i < 3; i++) {
        pid = fork();
        if (pid == -1) {
            perror("fork");
            exit(EXIT_FAILURE);
        } else if (pid == 0) {
            // 子进程
            close(pipefd[0]); // 关闭读端

            // 写入数据
            char message[BUF_SIZE];
            sprintf(message, "Hello from child %d\n", i);
            write(pipefd[1], message, strlen(message));
            printf("Child %d wrote message: %s", i, message);

            close(pipefd[1]); // 关闭写端
            exit(EXIT_SUCCESS);
        }
    }

    // 父进程
    close(pipefd[1]); // 关闭写端

    // 读取数据
    char buffer[BUF_SIZE];
    int total_bytes_read = 0;
    while (total_bytes_read < BUF_SIZE * 3) {
        int bytes_read = read(pipefd[0], buffer + total_bytes_read, BUF_SIZE);
        if (bytes_read == -1) {
            if (errno == EINTR) {
                continue;
            } else {
                perror("read");
                exit(EXIT_FAILURE);
            }
        } else if (bytes_read == 0) {
            break;
        }

        total_bytes_read += bytes_read;
    }
    printf("Parent read message: %s", buffer);

    close(pipefd[0]); // 关闭读端

    // 等待子进程结束
    for (int i = 0; i < 3; i++) {
        wait(NULL);
    }

    return 0;
}

在代码中，子进程先向管道中写入数据，然后关闭写端，等待其他子进程完成写入操作。父进程先关闭写端，然后从管道中读取数据，直到读取完所有数据。最后，父进程等待子进程结束。

需要注意的是，管道的读写操作是阻塞的，读写进程会阻塞在read和write函数上，直到管道中有数据或空间可以写入。如果多个进程同时写入管道，会产生竞争条件，需要使用信号量等方法进行同步，以保证进程间对管道的互斥访问。