// O_NOATIME 宏定义的扩展要求
#define _GNU_SOURCE 1
#include <fcntl.h>
#undef _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <linux/unistd.h>
#include <assert.h>
#include <limits.h>

static int pip[2];

void 
sleep_select(int sec)
{
    struct timeval timeout;

    timeout.tv_usec = 0;
    timeout.tv_sec = sec;

    select(0, NULL, NULL, NULL, &timeout);
}

static void 
*thread_read(void *userdata)
{
    char data[5] = {0};
    int ret;

    printf("p0: %d\n", pip[0]);
    printf("p1: %d\n", pip[1]);

    while (1)
    {
        fd_set fds;
        FD_ZERO(&fds);
        FD_SET(pip[0], &fds);
        struct timeval timeout = {10, 0};
        ret = select(pip[0] + 1, &fds, NULL, NULL, &timeout);
        if (ret < 0)
        {
            printf("select error\n");
            break;
        }
        else if (ret == 0)
        {
            // printf("no fd ready\n");
            continue;
        }
        else
        {
            if (FD_ISSET(pip[0], &fds) > 0)
            {
                read(pip[0], data, 5);
                printf("data: %s\n", data);
            }
        }
    }
}

static void *
thread_write(void)
{
    printf("thread_write\n");
    char data[] = "pipe-data";
    while (1)
    {
        sleep_select(1);
        write(pip[1], data, sizeof(data));
        /* 单次写入的数据长度超过 PIPE_BUF 时， 内核不保证写入的原子性*/
        if (sizeof(data) > PIPE_BUF)
        {
            printf("warn data is too long\n");
        }
    }
}

int main(int argc, char *argv[])
{
    char data[] = "data";
    pthread_t id;
    if (pipe(pip))
    {
        printf("pipe error\n");
        exit(-1);
    }

    printf("p0: %d\n", pip[0]);
    printf("p1: %d\n", pip[1]);

    fcntl(pip[0], F_SETFL, O_NOATIME); /* 提高性能 */
    fcntl(pip[1], F_SETFL, O_NOATIME);

    if (pthread_create(&id, NULL, thread_read, NULL))
    {
        printf("create thread error\n");
        exit(-1);
    }

    printf("pthread id = %x\n", id);
    pthread_create(&id, NULL, thread_write, NULL);

    // signal(SIGUSR1, mysignal);
    while (1)
    {
        sleep_select(2);
    }

    pthread_join(id, NULL);
}

无名管道(4)：通过管道同步进程
通过管道同步进程
管道其实就是一个文件

PIPE通信应用
通过管道同步进程
管道自带同步互斥机制：
管道的内核实现：fs/pipe.h
通过内核的锁、等待队列等机制实现
Write操作可能会阻塞进程
当内存缓冲区已满被读进程锁定
直到所有数据被写入到管道为止
Read操作进程可能会阻塞进程
读进程可以休眠在等待队列
直到所有子进程都关闭了管道的写入端描述符为止
父进程的写入端描述符也要关闭，否则父进程读管道时也会被阻塞
只有当所有的写端描述符都已关闭，且管道中的数据都被读出，对读端描述符调用read函数才会返回0(即读到EOF标志)
当所有的读取端和写入端都关闭，管道才能被销毁
管道缓冲区设置
管道缓冲区
管道对应的内存缓冲区大小
PIPE_BUF的容量是有限的：默认是65536字节
在不同OS下PIPE_BUF大小设置不同：在limits.h头文件中定义
写入管道的数据超过PIPE_BUF大小，内核会分割几块传输
最大值/proc/sys/fs/pipe-maxsize
查看打开的管道文件：cat /proc/PID/fd
设置缓冲区大小
特权用户：可以修改上限值
设置缓冲区大小：fcntl(fd, F_SETPIPE, size)