进程间的通信--无名管道

无名管道是 UNIX 系统 IPC(进程间通信)的最古老形式，所有 UNIX 系统都支持这种通信方式机制

管道的特点：

1. 半双工，数据在同一时刻只能在一个方向上流懂
2. 数据只能从管道的一段写入，另一端读出
3. 写入管道中的数据遵循先进先出的规则 
4. 管道所传送的数据是无格式的，要求管道的读出方与写入方必须事先约定好数据的格式，如多少字节算一个消息等。
5. 管道不是普通的文件，不属于某个文件系统，其只存在于内存中。
6. 管道在内存中对应一个缓冲区。不同的系统其大小不一定相同。
7.  从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据。
8. 管道没有名字，只能在具有公共祖先的进程(父进程与子进程，或者两个兄弟进程，具有亲缘关系)之间使用。

pipe函数

#include<unistd.h>

创建无名管道：

int pipe(int pipefd[2]);

参数：

        pipefd：为 int 型数组的首地址，存放了管道文件描述符 pipefd[0]，pipefd[1]

        

当一个管道创建时，它会创建两个文件描述符 fd[0]，fd[1] ，fd[0] 固定用于读管道，fd[1] 用于写管道，一般的文件  I/O 函数都可以用来操作管道( lseek() 除外)

返回值：成功返回 0，失败返回 -1 

 无名管道的创建

#include <cerrno>
#include<iostream>
#include <sched.h>
#include <unistd.h>
using namespace std;
int main()
{
    int pipefd[2]={0};
    //创建一个无名管道
    int ret=pipe(pipefd);
    if(ret==-1)
    {
        perror("create pipe error");
        return 1;
    }

    //pipefd[0]用于读，pipefd[1]用于写
    cout<<"pipefd[0]:"<<pipefd[0]<<" "<<"pipefd[1]:"<<
            pipefd[1]<<endl;
 
    //查看管道缓冲区的大小
    cout<<"read pipe size:"<<fpathconf(pipefd[0],_PC_PIPE_BUF)<<endl;
    cout<<"read pipe size:"<<fpathconf(pipefd[1],_PC_PIPE_BUF)<<endl;
    
    //关闭文件描述符
    close(pipefd[0]);
    close(pipefd[1]);
    return 0;

}

管道的读写特点
使用管道需要注意4种特殊情况(假设都是阻塞 I/O 操作，没有设置O_NONBLOCK标志):

1. 如果所有指向管道写端的文件描述符都关闭了(管道写端引用计数为0)，而仍然有进程从管道的读端读数据，那么管道中剩余的数据都被读取后，再次 read 会返回 0，就像读到文件末尾一样。
2. 如果有指向管道写端的文件描述符没关闭(管道写端引用计数大于0)，而持有管道写端的进程也没有向管道中写数据，这时有进程从管道读数据，那么管道中剩余的数据都被速取后，再次 read 会阻塞，直到管道中有数据可读了才读取数据并返回。
3. 如果所有指向管道读端的文件描述符都关闭了(管道读端引用计数为0)，这时有进程向管道的写端write，那么该进程会收到信号 SIGPIPE，通常会导致进程异常终止。当然也可对SIGPIPE 信号实施捕捉，不终止进程。
4. 如果有指向管道读端的文件描述符没关闭(管道读端引用计数大于0)，而持有管道读端的进程也没有从管道中读数据，这时有进程向管道写端写数据，那么在管道被写满时再次 write 会阻塞，直到管道中有空位置了才写入数据并返回。

即：

总结:读管道:

        管道中有数据，read返回实际读到的字节数。

管道中无数据:
        管道写端被全部关闭，read返回0(相当于读到文件结尾)
        写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)
写管道:
        管道读端全部被关闭，进程异常终止(也可使用捕捉SIGPIPE信号，使进程终止)
管道读端没有全部关闭:
        管道已满，write阻塞
        管道未满，write将数据写入，并返回实际写入的字节数。 

#include<fcntl.h>

设置非阻塞的方式：

        //获取原来的 flags

        int flags=fcntl(fd[0]，F_GETFL);

        //设置新的 flags

        flags |= O_NONBLOCK;     //  flags = flags | O_NONBLOCK;

        fcntl(fd[0]，F_SETFL，flags); 

        

如果写端没有关闭，读端设置为非阻塞，如果没有数据，直接返回 -1

查看管道缓冲区的大小的命令：ulimit -a

查看缓冲区大小函数：

        #include<unistd.h>

        可以通过 name 参数查看不同的属性值：

        long fpathconf(int fd，int name);

参数：

        fd：文件描述符

        name：

                _PC_PIPE_BUF ：查看缓冲区大小

                _PC_NAME_MAX：文件名字字节的上限

返回值：

        成功：根据 name 返回的值的意义不用

        失败：返回 -1

        

父子进程无名管道通信

 #include <cstdio>
#include<iostream>
#include <sched.h>
#include <string>
#include<unistd.h>
#include<error.h>
#include<string.h>
#include<fcntl.h>
using namespace std;
#define SIZE 64 

//父子进程使用无名管道通信
int main()
{
    int ret=0;
    pid_t pid;
    char buf[SIZE]={0}; //缓冲区大小
    int fds[2];
    //fork 之前创建pipe

    ret=pipe(fds);
    if(ret==-1)
    {
        perror("create pipe error");
        exit(1);
    }

    //创建子进程
    pid=fork();
    if(pid==-1)
    {
        perror("create child process error");
        exit(1);
    }
    
    //子进程
    if(pid==0)
    {
        //子进程读管道，关掉子进程的写端
        close(fds[1]);
    /*
        将读端fds[0]设置非阻塞：
        当管道没有数据时，返回-1，不会等待写端写入数据
            
    */
        //获取原来的flags
        //int flags=fcntl(fds[0],F_GETFL);

        //设置新的flags
        //flags|=O_NONBLOCK;  //flags=flags|O_NONBLOCK
        //fcntl(fds[0],F_SETFL,flags);


        //memset(buf,0,SIZE); buf数组初始化为0

        ret=read(fds[0],buf,sizeof(buf));  //子进程先执行，没有数据可读就会阻塞在这里
        if(ret<0)
        {
            perror("read error");
            exit(1);
        }
        cout<<"child process:"<<buf<<endl;
        close(fds[0]);
    }


    //父进程写管道，关掉父进程的读端
    if(pid>0)
    {
        close(fds[0]);
        sleep(1);
        ret=write(fds[1],"ABCDEFGHIJK",10);
        if(ret==-1)
        {
            perror("write error");
            exit(1);
        }
        //在读端设置为非阻塞 O_NONBLOCK 的情况下，
        //write函数调用会收到 SIGPIPE 的信号，进程终止，下面一句就不会输出了
        cout<<"parent process write length:"<<ret<<endl;
        close(fds[1]);
    }



    return 0;
}