(匿名)管道的读写规则

管道读写规则：
1、当没有数据可读时

O_NONBLOCK  disable(文件状态标志)未设置非阻塞的话 : read调用阻塞，即进程暂停执行，一直等到有数据来。
O_NONBLOCK enable: 设置非阻塞模式的话，无数据可读时，read调用返回-1，errno值为EAGAIN。

总之：阻塞模式的话，如果read无数据可读就阻塞；如果非阻塞模式的话，read无数据可读，则立即返回-1.

　　int fcntl(int fd,int cmd) cmd=F_GETFLF_SETFL: 获取或者设置文件状态标志

#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<string.h>

#include<signal.h>
#define ERR_EXIT(m)
    do
    {
        perror(m);
        exit(EXIT_FAILURE);
    }while(0)  //宏要求一条语句
int main(int argc,char*argv[])
{
    int pipefd[2];
    if(pipe(pipefd)==-1)
        ERR_EXIT("pipe error");
    pid_t pid;
    if((pid=fork())==-1)
        ERR_EXIT("fork error");
    else if(pid==0){//子进程发送数据给父进程
        sleep(3);//未设置文件状态标识时，文件对read阻塞，前三秒没有数据可读
        close(pipefd[0]);
        write(pipefd[1],"hello",5);
        close(pipefd[1]);
        exit(EXIT_SUCCESS);
    }
    close(pipefd[1]);
    char buf[10];
    int flags=fcntl(pipefd[0],F_GETFL);//获取文件状态标识
    fcntl(pipefd[0],F_SETFL,flags|O_NONBLOCK);//设置文件状态标识，非阻塞模式
    if(read(pipefd[0],buf,10)==-1) ERR_EXIT("read error");//默认文件pipefd[0]阻塞
    printf("buf=%s
",buf);
    close(pipefd[0]);
    return 0;
}

2、如果所有管道写端对应的文件描述符被关闭，则read返回0。

#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<string.h>

#include<signal.h>
#define ERR_EXIT(m)
    do
    {
        perror(m);
        exit(EXIT_FAILURE);
    }while(0)  //宏要求一条语句
int main(int argc,char*argv[])
{
    int pipefd[2];
    if(pipe(pipefd)==-1)
        ERR_EXIT("pipe error");
    pid_t pid;
    if((pid=fork())==-1)
        ERR_EXIT("fork error");
    else if(pid==0){
        close(pipefd[1]);//子进程写端关闭
        exit(EXIT_SUCCESS);
    }
    close(pipefd[1]);//父进程写端关闭
    sleep(1);
    char buf[10]={0};
    int ret=read(pipefd[0],buf,10);//读操作返回0
    printf("ret=%d
",ret);
    return 0;
}

3、如果所有管道读端对应的文件描述符被关闭，则write操作符产生信号SIGPIPE.

 #include<unistd.h>
 #include<sys/types.h>
 #include<sys/stat.h>
 #include<fcntl.h>
 #include<stdlib.h>
 #include<stdio.h>
 #include<errno.h>
 #include<string.h>
 
  #include<signal.h>
 #define ERR_EXIT(m)
     do
     {
         perror(m);
         exit(EXIT_FAILURE);
     }while(0)  //宏要求一条语句
   void handler(int sig)
　　{
　　　　printf("recv a sig=%d
",sig);
　　}
　　int main(int argc,char*argv[])
   {
　　　signal(SIGPIPE,handler);
     int pipefd[2];
     if(pipe(pipefd)==-1)
         ERR_EXIT("pipe error");
     pid_t pid;
     if((pid=fork())==-1)
         ERR_EXIT("fork error");
     else if(pid==0){//子进程发
         close(pipefd[0]);  //关闭子进程读端         exit(EXIT_SUCCESS);
     }
     close(pipefd[0]); //关闭父进程读端
     sleep(1);
     int ret= write(pipfd[1],"hello",5);
　　　if(ret == -1)
　　　　　　　　printf("write error"); //捕捉信号的话会执行到这，否则默认处理函数之间结束进程     return 0;
   }

4、当管道满的时候（不断往管道写入），write函数也有两种可能：

如果文件状态标志(O_NONBLOCK disable)阻塞（未设置），write调用阻塞；

文件状态标志（O_NONBLOCK）非阻塞, write返回-1   errno=EAGAIN.

同时这个例子还可以获取管道内核缓冲区的大小。

#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<string.h>

#include<signal.h>
#define ERR_EXIT(m)
    do
    {
        perror(m);
        exit(EXIT_FAILURE);
    }while(0)  //宏要求一条语句
int main(int argc,char*argv[])
{
    int pipefd[2];
    if(pipe(pipefd)==-1)
        ERR_EXIT("pipe error");
    int ret;
    int count=0;
    int flags=(pipefd[1],F_GETFL);
    fcntl(pipefd[1],F_SETFL,flags|O_NONBLOCK);//改为非阻塞，写满的话再写就会出错。默认阻塞，写满write就会阻塞
    while(1)
    {
        ret=write(pipefd[1],"a",1);//一个一个写会阻塞，若一下子写的超过64k要写完才返回。
        if(ret==-1){
            printf("err=%s
",strerror(errno));
            break;
　　　　 }
        count++;
    }
    printf("count=%d
",count);//65536字节.管道容量64k，管道容量不等于PIPE_BUF的大小，PIPE_BUF一般4k
    return 0;
}

5、当要写入的数据量不大于PIPE_BUF时，LINUX将保证写入的原子性，指多个进程向管道写入数据，各个进程数据连续，不被插入其他进程数据；当要写入的数据量大于PIPE_BUF时，LINUX将不再保证写入原子性。可能会被其他进程插入数据。PIPE_BUF一般为4KB。

阻塞模式并且n<=PIPE_BUF:所有数据原子性写入。可以打印出来，在头文件<linux/limits.h>中。不一定等同于管道容量；

非阻塞模式并且n<=PIPE_BUF:若空间不够，失败返回，不写入字符；

阻塞模式并且n>PIPEBUF:不保证原子性，直到n个字节全部被写完才返回；

非阻塞模式且n>PIPEBUF:失败同样不写入；若可以但不保证原子性。

#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<string.h>

#include<linux/limits.h>
#define TEST_SIZE 68*1024
#define ERR_EXIT(m)
    do
    {
        perror(m);
        exit(EXIT_FAILURE);
    }while(0)  //宏要求一条语句
int main(int argc,char*argv[])
{
    printf("pipe_buf=%d
",PIPE_BUF);
    int ret;
    char a[TEST_SIZE];//68KB
    char b[TEST_SIZE];
    memset(a,'A',sizeof(a));
    memset(b,'B',sizeof(b));
    int pipefd[2];
    if(pipe(pipefd)==-1)
        ERR_EXIT("pipe error");
    
    pid_t pid;
    //创建第一个子进程
    pid=fork();
    if(pid==0)
    {
        close(pipefd[0]);//关闭读端
        ret=write(pipefd[1],a,sizeof(a));//往管道写端写入68K数据。管道64k
        printf("apid=%d write %d bytes to pipe
",getpid(),ret);
        exit(0);
    }
    //再创建一个子进程，写入68k b
    pid=fork();
    if(pid==0)
    {
        close(pipefd[0]);
        ret=write(pipefd[1],b,sizeof(b));//写完68k才返回。管道大小64K.
        printf("bpid=%d write%d bytes to pipe
",getpid(),ret);
        exit(0);
    }
    //父进程
    close(pipefd[1]);
    sleep(1);//使子进程先到write()
    int fd=open("test.txt",O_WRONLY|O_CREAT|O_TRUNC,0644);
    char buf[1024*4]={0};//每次接收4k数据
    int n=1;
    while(1)
    {
        ret=read(pipefd[0],buf,sizeof(buf));//每次接收4k数据
        if(ret==0)
            break;//子进程都发完数据了，管道写端都关闭了。跳出循环
        //没发完的话，每次收到4k,打印最后一个字符。会有穿插，68k远远超出PIPE_BUF
        printf("n=%02d pid=%d read %d bytes from pipe buf[4095=]%c
",n++,getpid(),ret,buf[4095]);//打印输出收到的数据
        write(fd,buf,ret);//每次4k写入文件。
    }
    return 0;
}