1) 编写一个管道程序，要求能试验阻塞型读写过程中的各种情况，测试管道的默认大小（接收端不读管道的情况下，管道中最多能写多少数据）。

好的，这是一个比较复杂的问题。首先，管道是一种进程间通信的机制，可以用于在两个进程之间传递数据。管道是一个特殊的文件，它有一个读端和一个写端，数据从写端流入管道，再从读端流出管道。

在 Unix/Linux 系统中，管道默认大小是 64KB。当写入的数据量超过管道缓冲区大小时，写操作会被阻塞，直到有足够的空间来容纳数据。同样地，如果读取的数据量超过管道缓冲区大小，读操作也会被阻塞，直到有足够的数据可供读取。

为了测试阻塞型读写过程中的各种情况，可以编写一个简单的管道程序，其中包含两个进程，一个写进程和一个读进程。在写进程中，可以使用一个循环来向管道中写入大量数据，直到管道被填满。在读进程中，可以使用一个循环来读取管道中的数据，直到所有数据都被读取完毕。

以下是一个示例程序：

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

#define BUFFER_SIZE 1024

int main()
{
    int pipefd[2];
    char buffer[BUFFER_SIZE];
    int nbytes;

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

    int pid = fork();

    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // 子进程写入数据
        close(pipefd[0]); // 关闭读取端

        // 写入大量数据，直到管道被填满
        int total_bytes_written = 0;
        while (1) {
            int bytes_written = write(pipefd[1], buffer, BUFFER_SIZE);
            if (bytes_written == -1) {
                perror("write");
                exit(EXIT_FAILURE);
            }
            total_bytes_written += bytes_written;
            printf("子进程已写入 %d 字节数据\n", total_bytes_written);
        }

        close(pipefd[1]);
        exit(EXIT_SUCCESS);

    } else {
        // 父进程读取数据
        close(pipefd[1]); // 关闭写入端

        // 读取管道中的数据，直到所有数据都被读取完毕
        int total_bytes_read = 0;
        while (1) {
            nbytes = read(pipefd[0], buffer, BUFFER_SIZE);
            if (nbytes <= 0) {
                break;
            }
            total_bytes_read += nbytes;
            printf("父进程已读取 %d 字节数据\n", total_bytes_read);
        }

        close(pipefd[0]);
        exit(EXIT_SUCCESS);
    }

    return 0;
}

在该程序中，子进程向管道中写入大量数据，直到管道被填满。如果管道的缓冲区大小为 64KB，则需要写入 64 次，每次写入 1024 字节。在此期间，父进程试图从管道中读取数据，但由于管道被填满，读操作被阻塞。

当子进程写入 64KB 数据后，管道已满，此时写操作被阻塞。此时，可以尝试在另一个终端中运行命令 `ps aux | grep <子进程的PID>`，查看子进程的状态。可以发现，子进程处于睡眠状态，等待管道缓冲区中有足够的空间来容纳数据。

接下来，可以在父进程中加入一个 sleep 语句，让其睡眠一段时间，以模拟读操作被阻塞的情况。例如，可以在 while 循环中加入以下代码：

if (total_bytes_read >= 32 * BUFFER_SIZE) {
    printf("父进程睡眠 5 秒钟\n");
    sleep(5);
}

在此期间，子进程将继续向管道中写入数据，但由于管道已满，写操作将被阻塞。当父进程睡眠结束后，它将继续读取管道中的数据，直到所有数据都被读取完毕。

通过这种方式，可以测试管道的默认大小，并试验阻塞型读写过程中的各种情况。