無名管道(pipe)

管道可用於具有親緣關系進程間的通信，有名管道克服了管道沒有名字的限制，因此，除具有管道所具有的功能外，它還允許無親緣關系進程間的通信；

定義函數： int pipe（int filedes［2］）

filedes［0］為管道裏的讀取端

filedes［1］則為管道的寫入端。

實現機制：

管道是由內核管理的一個緩沖區，相當於我們放入內存中的一個紙條。管道的一端連接一個進程的輸出。這個進程會向管道中放入信息。管道的另一端連接一個進程的輸入，這個進程取出被放入管道的信息。一個緩沖區不需要很大，它被設計成為環形的數據結構，以便管道可以被循環利用。當管道中沒有信息的話，從管道中讀取的進程會等待，直到另一端的進程放入信息。當管道被放滿信息的時候，嘗試放入信息的進程會等待，直到另一端的進程取出信息。當兩個進程都終結的時候，管道也自動消失。

從原理上，管道利用fork機制建立，從而讓兩個進程可以連接到同一個PIPE上。最開始的時候，上面的兩個箭頭都連接在同一個進程Process 1上(連接在Process 1上的兩個箭頭)。當fork復制進程的時候，會將這兩個連接也復制到新的進程(Process 2)。隨後，每個進程關閉自己不需要的一個連接 (兩個黑色的箭頭被關閉; Process 1關閉從PIPE來的輸入連接，Process 2關閉輸出到PIPE的連接)，這樣，剩下的紅色連接就構成了如上圖的PIPE

一、管道讀寫註意點

1.必須在系統調用fork之前調用pipe，否則子進程不會繼承文件描述符

2.只有在管道讀端存在時，向管道寫入才有意義；否則，會收到內核中的出錯信號：SIFPIPE只有在管道讀端存在時，向管道寫入才有意義；否則，會收到內核中的出錯信號：SIFPIPE

3.向管道寫入數據時不保證寫入的原子性，管道緩沖區一有空閑區域，寫進程就試圖向其寫入內容。若讀進程不讀取管道中的內容，則寫進程會一直阻塞。

4.父子進程在運行時，它們的先後順序得不到保證。因此在這裏，為保證父進程關閉讀描述符，可向子進程加入sleep(2)。

二、實例

1.無名管道

/*pipe_rw.c*/
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
    
 
int pipe_fd[2];
    pid_t pid;
    char buf_r[100];
    char* p_wbuf;
    int r_num;
    memset(buf_r,0,sizeof(buf_r));
    if(pipe(pipe_fd)<0)
    {
    printf("pipe create error\n");
    return -1;
    }
    if((pid=fork())==0)    //若是子進程
    {
        printf("\n");
        /*關閉子進程管道寫端。睡眠2秒，確保父進程已相應地關閉了管道讀端*/
        close(pipe_fd[1]);
        sleep(2);
        /*子進程讀取管道內容*/
        if((r_num=read(pipe_fd[0],buf_r,100))>0){
            printf(   "%d numbers read from the pipe is %s\n",r_num,buf_r);
        }    
        /*關閉子進程讀端*/
        close(pipe_fd[0]);
        exit(0);
      }
    else if(pid>0)
    {    /*關閉父進程讀端*/
        close(pipe_fd[0]);
        /*分兩次向管道寫入數據*/
        if(write(pipe_fd[1],"Hello",5)!=-1)
            printf("parent write1 success!\n");
        if(write(pipe_fd[1]," Pipe",5)!=-1)
            printf("parent write2 success!\n");
        /*關閉父進程寫端並睡眠3秒，讓子進程讀數據*/
        close(pipe_fd[1]);
        sleep(3);
        /*收集子進程退出信息*/
        waitpid(pid,NULL,0);
        exit(0);
    }
}

運行結果如下：

[[email protected] ipc]# ./pipe_rw 
parent write1 success!  
parent write2 success!  
10 numbers read from the pipe is Hello Pipe

2.命名管道(named PIPE)

由於基於fork機制，所以管道只能用於父進程和子進程之間，或者擁有相同祖先的兩個子進程之間 (有親緣關系的進程之間)。為了解決這一問題，Linux提供了FIFO方式連接進程。FIFO又叫做命名管道(named PIPE)。

FIFO (First in, First out)為一種特殊的文件類型，它在文件系統中有對應的路徑。當一個進程以讀(r)的方式打開該文件，而另一個進程以寫(w)的方式打開該文件，那麽內核就會在這兩個進程之間建立管道，所以FIFO實際上也由內核管理，不與硬盤打交道。之所以叫FIFO，是因為管道本質上是一個先進先出的隊列數據結構，最早放入的數據被最先讀出來，從而保證信息交流的順序。FIFO只是借用了文件系統(file system,命名管道是一種特殊類型的文件，因為Linux中所有事物都是文件，它在文件系統中以文件名的形式存在。)來為管道命名。寫模式的進程向FIFO文件中寫入，而讀模式的進程從FIFO文件中讀出。當刪除FIFO文件時，管道連接也隨之消失。FIFO的好處在於我們可以通過文件的路徑來識別管道，從而讓沒有親緣關系的進程之間建立連接

函數原型：

#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char *filename, mode_t mode);
int mknode(const char *filename, mode_t mode | S_IFIFO, (dev_t) 0 );

其中pathname是被創建的文件名稱，mode表示將在該文件上設置的權限位和將被創建的文件類型(在此情況下為S_IFIFO)，dev是當創建設備特殊文件時使用的一個值。因此，對於先進先出文件它的值為0。

FIFO讀寫規則

1.從FIFO中讀取數據： 約定：如果一個進程為了從FIFO中讀取數據而阻塞打開了FIFO，那麽稱該進程內的讀操作為設置了阻塞標誌的讀操作

2.從FIFO中寫入數據： 約定：如果一個進程為了向FIFO中寫入數據而阻塞打開FIFO，那麽稱該進程內的寫操作為設置了阻塞標誌的寫操作。

一旦創建了了FIFO，就可open去打開它，可以使用open，read，close等去操作FIFO 當打開FIFO時，非阻塞標誌（O_NONBLOCK）將會對讀寫產生如下影響：

1、沒有使用O_NONBLOCK：訪問要求無法滿足時進程將阻塞。如試圖讀取空的FIFO，將導致進程阻塞；

2、使用O_NONBLOCK：訪問要求無法滿足時不阻塞，立即出錯返回，errno是ENXIO；

/*fifo_write.c*/
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define FIFO_SERVER "/tmp/myfifo"

main(int argc,char** argv)
{
    int fd;
    char w_buf[100];
    int nwrite;
    
    if(fd==-1)
        if(errno==ENXIO)
            printf("open error; no reading process\n");
    /*打開有名管道，並設置為非阻塞*/
    fd=open(FIFO_SERVER,O_WRONLY|O_NONBLOCK,0);
    if(argc==1)
        printf("Please send something\n");
    strcpy(w_buf,argv[1]);
    /*向管道寫入字符串*/
    if((nwrite=write(fd,w_buf,100))==-1)
    {
        if(errno==EAGAIN)
            printf("The FIFO has not been read yet.Please try later\n");
    }
    else 
        printf("write %s to the FIFO\n",w_buf);
}


/*fifo_read.c*/

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define FIFO "/tmp/myfifo"

main(int argc,char** argv)
{
    char buf_r[100];
    int  fd;
    int  nread;
    
    /*創建有名管道,並設置相應的權限*/
    if((mkfifo(FIFO,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST))
        printf("cannot create fifoserver\n");
    printf("Preparing for reading bytes...\n");
    
    memset(buf_r,0,sizeof(buf_r));
    /*打開有名管道，並設置非阻塞標誌*/
    fd=open(FIFO,O_RDONLY|O_NONBLOCK,0);
    if(fd==-1)
    {
        perror("open");
        exit(1);    
    }
    while(1)
    {
        memset(buf_r,0,sizeof(buf_r));
        /*讀取管道中的字符串*/
        if((nread=read(fd,buf_r,100))==-1){
            if(errno==EAGAIN)
                printf("no data yet\n");
        }
        printf("read %s from FIFO\n",buf_r);
        sleep(1);
    }    
    pause();
    unlink(FIFO);//這個誰mkfifo創建誰釋放 
}

運行結果：

終端1：

[[email protected] ipc]# ./fifo_write 123123  
write 123123 to the FIFO  

終端2：

[[email protected] ipc]# ./fifo_read
Preparing for reading bytes...
read  from FIFO
read  from FIFO
read  from FIFO
read  from FIFO
read  from FIFO
read 123123 from FIFO
read  from FIFO

總結：

1.read沒有數據read阻塞，read讀取後數據被刪除

2.數據有序，安裝寫入的順序

3.打開的描述符號可以讀寫(two-way)

4.管道文件關閉後，數據不持久

5.管道的數據在內核緩沖

6.有名管道的名字僅僅是內核識別是否放回同一個fd的標識

Linux 進程間通信之管道(pipe),(fifo)