天天看點
傳回

Linux pipe(管道)

1、 管道概述及相關API應用

1.1 管道相關的關鍵概念

管道是Linux 支援的最初Unix IPC形式之一，具有以下特點：

  • 管道是半雙工的，資料隻能向一個方向流動；需要雙方通信時，需要建立起兩個管道；
  • 隻能用于父子程序或者兄弟程序之間（具有親緣關系的程序）；
  • 單獨構成一種獨立的檔案系統：管道對于管道兩端的程序而言，就是一個檔案，但它不是普通的檔案，它不屬于某種檔案系統，而是自立門戶，單獨構成一種檔案系統，并且隻存在與記憶體中。
  • 資料的讀出和寫入：一個程序向管道中寫的内容被管道另一端的程序讀出。寫入的内容每次都添加在管道緩沖區的末尾，并且每次都是從緩沖區的頭部讀出資料。

  • 管道分為無名管道和有名管道，其中無名管道不屬于任何檔案系統，隻存在于記憶體中，它是無名無形的，但是可以把它看作一種特殊的檔案，通過使用普通檔案的read(),write()函數對管道進行操作，

    有名管道是有名有形的，為了使用這種管道，LINUX中設立了一個專門的特殊檔案系統--管道檔案，它存在于檔案系統中，任何程序可以在任何時候通過有名管道的路徑和檔案名來通路管道。但是在磁盤上的隻是一個節點，而檔案的資料則隻存在于記憶體緩沖頁面中，與普通管道一樣。

  • pipe是Linux中最經典的程序間通信手段，在終端裡通常用來組合指令，例如“ls -l｜wc -l”。它的作用很直覺，就是使得前一個程序的輸出作為後一個程序的輸入，在概念上很符合“管道”的意思。

1.2管道的建立：

#include

int pipe(int fd[2])

該函數建立的管道的兩端處于一個程序中間，在實際應用中沒有太大意義，是以，一個程序在由pipe()建立管道後，一般再fork一個子程序，然後通過管道實作父子程序間的通信（是以也不難推出，隻要兩個程序中存在親緣關系，這裡的親緣關系指的是具有共同的祖先，都可以采用管道方式來進行通信）。

1.3管道的讀寫規則：

管道兩端可分别用描述字fd[0]以及fd[1]來描述，需要注意的是，管道的兩端是固定了任務的。即一端隻能用于讀，由描述字fd[0]表示，稱其為管道讀端；另一端則隻能用于寫，由描述字fd[1]來表示，稱其為管道寫端。如果試圖從管道寫端讀取資料，或者向管道讀端寫入資料都将導緻錯誤發生。一般檔案的I/O函數都可以用于管道，如close、read、write等等。

從管道中讀取資料：

  • 如果管道的寫端不存在，則認為已經讀到了資料的末尾，讀函數傳回的讀出位元組數為0；
  • 當管道的寫端存在時，如果請求的位元組數目大于PIPE_BUF，則傳回管道中現有的資料位元組數，如果請求的位元組數目不大于PIPE_BUF，則傳回管道中現有資料位元組數（此時，管道中資料量小于請求的資料量）；或者傳回請求的位元組數（此時，管道中資料量不小于請求的資料量）。注：（PIPE_BUF在include/linux/limits.h中定義，不同的核心版本可能會有所不同。Posix.1要求PIPE_BUF至少為512位元組，red hat 7.2中為4096）。

關于管道的讀規則驗證：

#include

#include

#include

main()

{

int pipe_fd[2];

pid_t pid;

char r_buf[100];

char w_buf[4];

char* p_wbuf;

int r_num;

int cmd;

memset(r_buf,0,sizeof(r_buf));

memset(w_buf,0,sizeof(r_buf));

p_wbuf=w_buf;

if(pipe(pipe_fd)<0)

{

printf("pipe create error ");

return -1;

}

if((pid=fork())==0)

{

printf(" ");

close(pipe_fd[1]);

sleep(3);//確定父程序關閉寫端

r_num=read(pipe_fd[0],r_buf,100);

printf( "read num is %d the data read from the pipe is %d ",r_num,atoi(r_buf));

close(pipe_fd[0]);

exit();

}

else if(pid>0)

{

close(pipe_fd[0]);//read

strcpy(w_buf,"111");

if(write(pipe_fd[1],w_buf,4)!=-1)

printf("parent write over ");

close(pipe_fd[1]);//write

printf("parent close fd[1] over ");

sleep(10);

}

}

向管道中寫入資料：

  • 向管道中寫入資料時，linux将不保證寫入的原子性，管道緩沖區一有空閑區域，寫程序就會試圖向管道寫入資料。如果讀程序不讀走管道緩沖區中的資料，那麼寫操作将一直阻塞。

    注：隻有在管道的讀端存在時，向管道中寫入資料才有意義。否則，向管道中寫入資料的程序将收到核心傳來的SIFPIPE信号，應用程式可以處理該信号，也可以忽略（預設動作則是應用程式終止）。

對管道的寫規則的驗證1：寫端對讀端存在的依賴性

#include

#include

main()

{

int pipe_fd[2];

pid_t pid;

char r_buf[4];

char* w_buf;

int writenum;

int cmd;

memset(r_buf,0,sizeof(r_buf));

if(pipe(pipe_fd)<0)

{

printf("pipe create error ");

return -1;

}

if((pid=fork())==0)

{

close(pipe_fd[0]);

close(pipe_fd[1]);

sleep(10);

exit();

}

else if(pid>0)

{

sleep(1); //等待子程序完成關閉讀端的操作

close(pipe_fd[0]);//write

w_buf="111";

if((writenum=write(pipe_fd[1],w_buf,4))==-1)

printf("write to pipe error ");

else

printf("the bytes write to pipe is %d ", writenum);

close(pipe_fd[1]);

}

}

則輸出結果為： Broken pipe,原因就是該管道以及它的所有fork()産物的讀端都已經被關閉。如果在父程序中保留讀端，即在寫完pipe後，再關閉父程序的讀端，也會正常寫入pipe，讀者可自己驗證一下該結論。是以，在向管道寫入資料時，至少應該存在某一個程序，其中管道讀端沒有被關閉，否則就會出現上述錯誤（管道斷裂,程序收到了SIGPIPE信号，預設動作是程序終止）

對管道的寫規則的驗證2：linux不保證寫管道的原子性驗證

#include

#include

#include

main(int argc,char**argv)

{

int pipe_fd[2];

pid_t pid;

char r_buf[4096];

char w_buf[4096*2];

int writenum;

int rnum;

memset(r_buf,0,sizeof(r_buf));

if(pipe(pipe_fd)<0)

{

printf("pipe create error ");

return -1;

}

if((pid=fork())==0)

{

close(pipe_fd[1]);

while(1)

{

sleep(1);

rnum=read(pipe_fd[0],r_buf,1000);

printf("child: readnum is %d ",rnum);

}

close(pipe_fd[0]);

exit();

}

else if(pid>0)

{

close(pipe_fd[0]);//write

memset(r_buf,0,sizeof(r_buf));

if((writenum=write(pipe_fd[1],w_buf,1024))==-1)

printf("write to pipe error ");

else

printf("the bytes write to pipe is %d ", writenum);

writenum=write(pipe_fd[1],w_buf,4096);

close(pipe_fd[1]);

}

}

輸出結果：

the bytes write to pipe 1000

the bytes write to pipe 1000 //注意，此行輸出說明了寫入的非原子性

the bytes write to pipe 1000

the bytes write to pipe 1000

the bytes write to pipe 1000

the bytes write to pipe 120 //注意，此行輸出說明了寫入的非原子性

the bytes write to pipe 0

the bytes write to pipe 0

......

結論：

寫入數目小于4096時寫入是非原子的！

如果把父程序中的兩次寫入位元組數都改為5000，則很容易得出下面結論：

寫入管道的資料量大于4096位元組時，緩沖區的空閑空間将被寫入資料（補齊），直到寫完所有資料為止，如果沒有程序讀資料，則一直阻塞。

1.4管道應用執行個體：

執行個體一：用于shell

管道可用于輸入輸出重定向，它将一個指令的輸出直接定向到另一個指令的輸入。比如，當在某個shell程式（Bourne shell或C shell等）鍵入who│wc -l後，相應shell程式将建立who以及wc兩個程序和這兩個程序間的管道。考慮下面的指令行：

$kill -l 運作結果見 附一。

$kill -l | grep SIGRTMIN 運作結果如下：

30) SIGPWR 31) SIGSYS 32) SIGRTMIN 33) SIGRTMIN+1

34) SIGRTMIN+2 35) SIGRTMIN+3 36) SIGRTMIN+4 37) SIGRTMIN+5

38) SIGRTMIN+6 39) SIGRTMIN+7 40) SIGRTMIN+8 41) SIGRTMIN+9

42) SIGRTMIN+10 43) SIGRTMIN+11 44) SIGRTMIN+12 45) SIGRTMIN+13

46) SIGRTMIN+14 47) SIGRTMIN+15 48) SIGRTMAX-15 49) SIGRTMAX-14

執行個體二：用于具有親緣關系的程序間通信

下面例子給出了管道的具體應用，父程序通過管道發送一些指令給子程序，子程序解析指令，并根據指令作相應處理。

#include

#include

main()

{

int pipe_fd[2];

pid_t pid;

char r_buf[4];

char** w_buf[256];

int childexit=0;

int i;

int cmd;

memset(r_buf,0,sizeof(r_buf));

if(pipe(pipe_fd)<0)

{

printf("pipe create error ");

return -1;

}

if((pid=fork())==0)

//子程序：解析從管道中擷取的指令，并作相應的處理

{

printf(" ");

close(pipe_fd[1]);

sleep(2);

while(!childexit)

{

read(pipe_fd[0],r_buf,4);

cmd=atoi(r_buf);

if(cmd==0)

{

printf("child: receive command from parent over now child process exit ");

childexit=1;

}

else if(handle_cmd(cmd)!=0)

return;

sleep(1);

}

close(pipe_fd[0]);

exit();

}

else if(pid>0)

//parent: send commands to child

{

close(pipe_fd[0]);

w_buf[0]="003";

w_buf[1]="005";

w_buf[2]="777";

w_buf[3]="000";

for(i=0;i<4;i++)

write(pipe_fd[1],w_buf[i],4);

close(pipe_fd[1]);

}

}

//下面是子程序的指令處理函數（特定于應用）：

int handle_cmd(int cmd)

{

if((cmd<0)||(cmd>256))

//suppose child only support 256 commands

{

printf("child: invalid command ");

return -1;

}

printf("child: the cmd from parent is %d ", cmd);

return 0;

}

1.5管道的局限性

管道的主要局限性正展現在它的特點上：

  • 隻支援單向資料流；
  • 隻能用于具有親緣關系的程序之間；
  • 沒有名字；
  • 管道的緩沖區是有限的（管道制存在于記憶體中，在管道建立時，為緩沖區配置設定一個頁面大小）；

管道所傳送的是無格式位元組流，這就要求管道的讀出方和寫入方必須事先約定好資料的格式，比如多少位元組算作一個消息（或指令、或記錄）等等；

Linux管道的實作機制

在Linux中，管道是一種使用非常頻繁的通信機制。從本質上說，管道也是一種檔案，但它又和一般的檔案有所不同，管道可以克服使用檔案進行通信的兩個問題，具體表現為：

限制管道的大小。實際上，管道是一個固定大小的緩沖區。在Linux中，該緩沖區的大小為1頁，即4K位元組，使得它的大小不象檔案那樣不加檢驗地增長。使用單個固定緩沖區也會帶來問題，比如在寫管道時可能變滿，當這種情況發生時，随後對管道的write()調用将預設地被阻塞，等待某些資料被讀取，以便騰出足夠的空間供write()調用寫。

讀取程序也可能工作得比寫程序快。當所有目前程序資料已被讀取時，管道變空。當這種情況發生時，一個随後的read()調用将預設地被阻塞，等待某些資料被寫入，這解決了read()調用傳回檔案結束的問題。

注意：從管道讀資料是一次性操作，資料一旦被讀，它就從管道中被抛棄，釋放空間以便寫更多的資料。

1. 管道的結構

在 Linux 中，管道的實作并沒有使用專門的資料結構，而是借助了檔案系統的file結構和VFS的索引節點inode。通過将兩個 file 結構指向同一個臨時的 VFS 索引節點，而這個 VFS 索引節點又指向一個實體頁面而實作的。如圖 7.1所示。

圖7.1 管道結構示意圖

Linux&amp;nbsp;pipe(管道)

圖7.1中有兩個 file 資料結構，但它們定義檔案操作例程位址是不同的，其中一個是向管道中寫入資料的例程位址，而另一個是從管道中讀出資料的例程位址。這樣，使用者程式的系統調用仍然是通常的檔案操作，而核心卻利用這種抽象機制實作了管道這一特殊操作。

2.管道的讀寫

管道實作的源代碼在fs/pipe.c中，在pipe.c中有很多函數，其中有兩個函數比較重要，即管道讀函數pipe_read()和管道寫函數pipe_wrtie()。管道寫函數通過将位元組複制到 VFS 索引節點指向的實體記憶體而寫入資料，而管道讀函數則通過複制實體記憶體中的位元組而讀出資料。當然，核心必須利用一定的機制同步對管道的通路，為此，核心使用了鎖、等待隊列和信号。

當寫程序向管道中寫入時，它利用标準的庫函數write()，系統根據庫函數傳遞的檔案描述符，可找到該檔案的 file 結構。file 結構中指定了用來進行寫操作的函數（即寫入函數）位址，于是，核心調用該函數完成寫操作。寫入函數在向記憶體中寫入資料之前，必須首先檢查 VFS 索引節點中的資訊，同時滿足如下條件時，才能進行實際的記憶體複制工作：

記憶體中有足夠的空間可容納所有要寫入的資料；

記憶體沒有被讀程式鎖定。

如果同時滿足上述條件，寫入函數首先鎖定記憶體，然後從寫程序的位址空間中複制資料到記憶體。否則，寫入程序就休眠在 VFS 索引節點的等待隊列中，接下來，核心将調用排程程式，而排程程式會選擇其他程序運作。寫入程序實際處于可中斷的等待狀态，當記憶體中有足夠的空間可以容納寫入資料，或記憶體被解鎖時，讀取程序會喚醒寫入程序，這時，寫入程序将接收到信号。當資料寫入記憶體之後，記憶體被解鎖，而所有休眠在索引節點的讀取程序會被喚醒。

管道的讀取過程和寫入過程類似。但是，程序可以在沒有資料或記憶體被鎖定時立即傳回錯誤資訊，而不是阻塞該程序，這依賴于檔案或管道的打開模式。反之，程序可以休眠在索引節點的等待隊列中等待寫入程序寫入資料。當所有的程序完成了管道操作之後，管道的索引節點被丢棄，而共享資料頁也被釋放。

因為管道的實作涉及很多檔案的操作,是以,當讀者學完有關檔案系統的内容後來讀pipe.c中的代碼，你會覺得并不難了解

(轉自Internet)

Linux
上一篇: maven 編譯報錯集錦
下一篇: linux&amp;nbsp;Tar&amp;nbsp;指令詳解linux Tar 指令詳解

繼續閱讀