1. 寫在前面
linux系統核心為上層應用程式提供了多種程式間通訊(IPC)的手段，適用於不同的場景，有些解決程式間資料傳遞的問題，另一些則解決程式間的同步問題。對於同樣一種IPC機制，又有不同的API供應用程式使用，目前有POSIX IPC以及System V IPC可以為應用程式提供服務。後續的系列文章將逐一介紹訊息佇列，共享記憶體，訊號量，socket，fifo等程式間通訊方法，本篇文章主要總結了管道相關係統呼叫的使用方式。文中程式碼可以在這個程式碼倉庫中獲取，程式碼中使用了我自己實現的一個單元測試框架，對測試框架感興趣的同學可以參考上一篇文章。
2. pipe介紹
在linux環境進行日常開發時，管道是一種經常用到的程式間通訊方法。在shell環境下，'|'就是連線兩個程式的管道，它可以把一個程式的標準輸出透過管道寫到另一個程式的標準輸入，利用管道以及重定向，各種命令列工具經過組合之後可以實現一個及其複雜的功能，這也是繼承自UNIX的一種程式設計哲學。
除了在shell指令碼中使用管道，另一種方式是透過系統呼叫去操作管道。使用pipe或者pipe2建立管道，得到兩個檔案描述符，分別是管道的讀端和寫端，有了檔案描述符，程式就可以像讀寫普通檔案一樣對管道進行read和write操作，操作完成之後呼叫close關閉管道的兩個檔案描述符即可。可以看到，當完成建立之後，管道的使用和普通檔案相比沒有什麼區別。
管道有兩個特點: 1) 通常只能在有親緣關係的程式之間進行通訊； 2) 閱後即焚；有親緣關係是指，通訊的兩個程式可以是父子程式或者兄弟程式，這裡的父子和兄弟是一個廣義的概念, 子程式可以是父程式呼叫了多次fork建立出來的，而不僅侷限在只經過一次fork，總之，只要通訊雙方的程式拿到了管道的檔案描述符就可以使用管道了。說”閱後即焚“是因為管道中的資料在被程式讀取之後就會被管道清除掉。有一個形象的比喻說，管道就像某個程式家族各個成員之間傳遞情報的中轉站，情報內容閱後即焚。
3. pipe的基本使用
在使用管道時，需要注意管道中資料的流動方向，通常都是把管道作為一個單向的資料通道使用的。雖然通訊雙方可以都持有管道的讀端和寫端，然後使用同一個管道實現雙向通訊，但這種方式實際上很少使用。下面透過幾段程式碼說明幾種使用管道的方法：
3.1 自言自語
管道雖然時程式間通訊的一種手段，但一個程式自言自語也是可以的，核心並沒有限制管道的兩端必須由不同的程式操作。下面的程式碼展示了一個孤獨的程式怎樣透過管道自言自語，程式碼中使用了自己實現的測試框架cutest。執行之後它將從管道的另一頭收到前一個時刻發給自己的訊息。
CUTEST_CASE(basic_pipe, talking_to_myself) {
int pipefd[2];
pipe(pipefd);
const char *msg = "I'm talking to myself";
write(pipefd[1], msg, strlen(msg));
char buf[32];
read(pipefd[0], buf, 32);
printf("talking_to_myself: %s\n", buf);
close(pipefd[0]);
close(pipefd[1]);
}
3.2 父程式向子程式傳遞資料
自言自語始終是太過無聊，是時候讓父子程式之間聊點什麼了。因為fork之後的子程式會繼承父程式的檔案描述符，fork之前父程式向管道寫入的資料，子程式可以在管道的另一端讀到。
CUTEST_CASE(basic_pipe, parent2child) {
int pipefd[2];
pipe(pipefd);
const char *msg = "parent write, child read";
write(pipefd[1], msg, strlen(msg));
if (fork() == 0) {
close(pipefd[1]);
char buf[64];
memset(buf, 0, 64);
read(pipefd[0], buf, 64);
printf("parent2child: %s\n", buf);
exit(0);
}
close(pipefd[0]);
close(pipefd[1]);
}
3.2 自程式向父程式傳遞資料
管道的方向是由通訊雙方操作的檔案描述符決定的，子程式同樣可以傳遞訊息給父程式。
CUTEST_CASE(basic_pipe, child2parent) {
int pipefd[2];
pipe(pipefd);
if (fork() == 0) {
close(pipefd[0]);
const char *msg = "parent read, child write";
write(pipefd[1], msg, strlen(msg));
close(pipefd[1]);
exit(0);
}
close(pipefd[1]);
char buf[64];
memset(buf, 0, 64);
read(pipefd[0], buf, 64);
printf("child2parent: %s\n", buf);
close(pipefd[0]);
}
3.3 父程式向多個子程式傳遞資料
當有多個子程式時，只要它們持有了管道的檔案描述符，就可以利用管道通訊，把父程式寫進管道的資料讀取出來。當然，在具體的應用中需要考慮子程式的讀取順序等因素，下面的例子只是簡單的建立了多個子程式，每個程式讀取一個int型別的資料，開始階段由父程式向管道寫入資料，需要說明一點，三個子程式並沒有將管道內的資料都讀完，當所有引用了這個管道的檔案描述符都關閉了之後，核心也會在適當的時機銷燬自己維護的管道。
void fork_child_read(int id, int pipefd[2], const char *msg_pregix) {
if (fork() == 0) {
close(pipefd[1]);
int n;
read(pipefd[0], &n, sizeof(int));
printf("%s: child %d get data %d\n", msg_pregix, id, n);
close(pipefd[0]);
exit(0);
}
}
CUTEST_CASE(basic_pipe, parent2children) {
int pipefd[2];
pipe(pipefd);
for (int i = 1; i <= 10; i++)
write(pipefd[1], &i, sizeof(int));
const char *msg_prefix = "parent2children:";
fork_child_read(1, pipefd, msg_prefix);
fork_child_read(2, pipefd, msg_prefix);
fork_child_read(3, pipefd, msg_prefix);
close(pipefd[0]);
close(pipefd[1]);
}
3.4 父程式接收多個子程式的資料
考慮這樣一種場景，一個任務需要由多個子程式進行處理，最終的計算結果需要由父程式彙總，下面的程式碼模擬了這樣的場景，程式碼中建立了兩個子程式向管道寫入資料，父程式則一直嘗試讀取管道內的資料。
void fork_child_write(int pipefd[2], int data) {
if (fork() == 0) {
close(pipefd[0]);
write(pipefd[1], &data, sizeof(int));
close(pipefd[1]);
exit(0);
}
}
CUTEST_CASE(basic_pipe, children2parent) {
int pipefd[2];
pipe(pipefd);
int data[] = {512, 1024};
fork_child_write(pipefd, data[0]);
fork_child_write(pipefd, data[1]);
close(pipefd[1]);
int n;
while (read(pipefd[0], &n, sizeof(int)) == sizeof(int)) {
printf("children2parent: get data %d\n", n);
}
close(pipefd[0]);
}
3.5 兄弟程式之間傳遞資料
如果有兩個兄弟程式，程式A需要得到程式B的計算結果之後才能完成自己的任務，這時也可以用管道通訊。程式碼中分別建立了兩個程式對管道進行寫和讀操作，實際應用中經常還需要一種通知機制，讓等待的程式知道它依賴的任務已經就緒了，這需要用到訊號量，後續文章會介紹。下面程式碼的第二個程式在read操作時是阻塞的，會一直等到管道中資料可讀，因為建立管道時沒有指定O_NONBLOCK標誌。
CUTEST_CASE(basic_pipe, two_children) {
int pipefd[2];
pipe(pipefd);
const char *msg = "pipe between two children";
if (fork() == 0) {
close(pipefd[0]);
write(pipefd[1], msg, strlen(msg));
close(pipefd[1]);
exit(0);
}
if (fork() == 0) {
close(pipefd[1]);
char buf[64];
memset(buf, 0, 64);
read(pipefd[0], buf, 64);
printf("two_children: %s\n", buf);
close(pipefd[0]);
exit(0);
}
close(pipefd[0]);
close(pipefd[1]);
}
3.6 阻塞和非阻塞的問題
前面的例子中提到了管道的阻塞和非阻塞，這裡詳細說明一下這個問題。對於一個阻塞的管道，如果程式在read時，系統中存在沒有關閉的寫端檔案描述符，但此時管道是空的，read操作就會阻塞在這裡。可以這樣理解，因為寫端的存在，read就固執地認為在未來的某個時刻一定會有人會向管道中寫入資料，所以它就阻塞在這裡。對於非阻塞的管道，在前面的條件下，read會立即返回。上述的特性就要求我們在使用阻塞型別的管道時要及時關閉不使用的檔案描述符，因為程式read操作時在等待的寫端檔案描述符很可能是由當前程式開啟的，當系統中管道的其他寫端都關閉了的時候，當前程式的read就會出現自己等自己的問題，類似死鎖。
CUTEST_CASE(basic_pipe, blocking_read) {
int pipefd[2];
pipe(pipefd);
if (fork() == 0) {
/* NOTE: remove the comment below if you don't want child process
* blocking while reading data from pipe. Otherwise you will see that
* there is still a "basic-pipe" process after you finish this test, and
* you have to kill it manually.*/
// close(pipefd[1]);
int num;
read(pipefd[0], &num, sizeof(int));
/* NOTE: since the write end of pipe is a valid file descriptor in
* current process, the print below should never execute.*/
printf("should NEVER goes here\n");
exit(0);
}
close(pipefd[0]);
close(pipefd[1]);
printf("blocking_read: parent process exit\n");
}
上述程式碼使用的是阻塞型別的管道，fork出的程式沒有關閉管道的寫端，然後執行了read操作，當父程式退出之後，系統中仍存在這個管道的寫端描述符，並且就在已經處於睡眠狀態下的子程式中，這種情況下將不會再有人向管道中寫入資料，子程式會一直睡眠。執行程式碼之後使用ps命令可以看到這個睡死過去的子程式。
3.7 測試執行結果
以下是上述測試的執行結果，可以看到在程式退出之後仍然由一個"basic-pipe"程式，這是因為3.6節中的程式碼在子程式中沒有及時關閉不使用的管道檔案描述符。此時不得不手動把睡死的程式kill掉了。
[junan@arch1 test-all]$ make install
[junan@arch1 test-all]$ ./script/run_test.sh basic-pipe
blocking_read: parent process exit
two_children: pipe between two children
children2parent: get data 512
children2parent: get data 1024
parent2children:: child 1 get data 1
parent2children:: child 2 get data 2
parent2children:: child 3 get data 3
child2parent: parent read, child write
talking_to_myself: I'm talking to myself
cutest summary:
[basic_pipe] suit result: 7/7
[basic_pipe::blocking_read] case result: Pass
[basic_pipe::two_children] case result: Pass
[basic_pipe::children2parent] case result: Pass
[basic_pipe::parent2children] case result: Pass
[basic_pipe::child2parent] case result: Pass
[basic_pipe::parent2child] case result: Pass
[basic_pipe::talking_to_myself] case result: Pass
parent2child: parent write, child read
[junan@arch1 test-all]$ ps -e|grep basic-pipe
18866 pts/2 00:00:00 basic-pipe
[junan@arch1 test-all]$ kill -9 18866
[junan@arch1 test-all]$ ps -e|grep basic-pipe
[junan@arch1 test-all]$
4. pipe的進階使用
以上的幾段示例程式碼說明了管道的一些基本使用方法和注意事項，下面看一個使用管道和多程式生成質數的問題。我們的需求是這樣的，給定一個整數nmax，生成[2, nmax]區間上的所有質數，並且要求生成質數的核心邏輯使用管道和多程式。第一次碰到這個問題是在xv6作業系統的lab中，也是為了說明pipe和fork的使用。
看到這裡，不妨先稍微思考一下？一個簡單的想法可能是這樣的，首先有一個函式，其功能是判斷輸入的n是否是質數，接下來遍歷[2, nmax]上的整數，並且用之前的函式把質數都過濾出來，但問題是如何用管道和多程式實現這個函式的過濾功能呢？OK, 思考結束，來看看管道加多程式版本的質數生成器演算法思路：
這個“質數篩子”中的每個程式主要有三個任務，1）從pipe1讀取第一個資料並列印出來，並且它一定是質數；2）用得到的質數過濾pipe1中的其他資料，並把過濾出來的資料寫入pipe2；3）fork自己的子程式，並把pipe2傳遞給它；具體的程式碼實現如下，當過濾之後沒有資料時，就不會繼續建立子程式了。
void generate_primes(int pipe1[2]) {
close(pipe1[1]);
int prime = 0;
int err = read(pipe1[0], &prime, sizeof(int));
if (err <= 0) {
close(pipe1[0]);
return;
}
printf("%d\n", prime);
int pipe2[2];
pipe(pipe2);
pid_t pid = fork();
if (pid == 0) {
generate_primes(pipe2);
} else {
int num = 0;
while ((err = read(pipe1[0], &num, sizeof(int))) > 0) {
if (num % prime) {
write(pipe2[1], &num, sizeof(int));
}
}
}
close(pipe1[0]);
close(pipe2[0]);
close(pipe2[1]);
exit(0);
}
CUTEST_SUIT(prime_numbers_pipe)
CUTEST_CASE(prime_numbers_pipe, prime_number_max30) {
int nmax = 30;
int pipe1[2];
pipe(pipe1);
for (int i = 2; i <= nmax; ++i)
write(pipe1[1], &i, sizeof(int));
if (fork() == 0) {
generate_primes(pipe1);
}
close(pipe1[0]);
close(pipe1[1]);
}
程式碼中生成的是2到30區間上的質數，執行結果如下：
[junan@arch1 test-all]$ ./script/run_test.sh prime-number-pipe
cutest summary:
[prime_numbers_pipe] suit result: 1/1
[prime_numbers_pipe::prime_number_max30] case result: Pass
2
3
5
7
11
13
17
19
23
29
[junan@arch1 test-all]$
5. 寫在最後
管道是一種比較基礎和常用的程式間通訊方法，在使用過程中需要注意及時關閉不再使用的檔案描述符的問題，否則可能使得程式一直睡眠。文中的程式碼示例可以在我的程式碼倉庫中找到，有興趣的可以自己clone下來實際跑跑看。後續會繼續更新其他的IPC相關的文章，並在最後使用各種IPC方法實現一個小專案，有想法的歡迎在評論區冒泡。