C/C++ 進程間通信 管道


使用匿名管道

一、什么是管道
如果你使用過Linux的命令,那么對於管道這個名詞你一定不會感覺到陌生,因為我們通常通過符號“|"來使用管道,但是管理的真正定義是什么呢?管道是一個進程連接數據流到另一個進程的通道,它通常是用作把一個進程的輸出通過管道連接到另一個進程的輸入。
 
舉個例子,在shell中輸入命令:ls -l | grep string,我們知道ls命令(其實也是一個進程)會把當前目錄中的文件都列出來,但是它不會直接輸出,而是把本來要輸出到屏幕上的數據通過管道輸出到grep這個進程中,作為grep這個進程的輸入,然后這個進程對輸入的信息進行篩選,把存在string的信息的字符串(以行為單位)打印在屏幕上。
 
二、使用popen函數
1、popen函數和pclose函數介紹
有靜就有動,有開就有關,與此相同,與popen函數相對應的函數是pclose函數,它們的原型如下:
 
  1. #include <stdio.h>  
  2. FILE* popen (const char *command, const char *open_mode);  
  3. int pclose(FILE *stream_to_close);  
poen函數允許一個程序將另一個程序作為新進程來啟動,並可以傳遞數據給它或者通過它接收數據。command是要運行的程序名和相應的參數。open_mode只能是"r(只讀)"和"w(只寫)"的其中之一。注意,popen函數的返回值是一個FILE類型的指針,而Linux把一切都視為文件,也就是說我們可以使用stdio I/O庫中的文件處理函數來對其進行操作。
 
如果open_mode是"r",主調用程序就可以使用被調用程序的輸出,通過函數返回的FILE指針,就可以能過stdio函數(如fread)來讀取程序的輸出;如果open_mode是"w",主調用程序就可以向被調用程序發送數據,即通過stdio函數(如fwrite)向被調用程序寫數據,而被調用程序就可以在自己的標准輸入中讀取這些數據。
 
pclose函數用於關閉由popen創建出的關聯文件流。pclose只在popen啟動的進程結束后才返回,如果調用pclose時被調用進程仍在運行,pclose調用將等待該進程結束。它返回關閉的文件流所在進程的退出碼。
 
2、例子
很多時候,我們根本就不知道輸出數據的長度,為了避免定義一個非常大的數組作為緩沖區,我們可以以塊的方式來發送數據,一次讀取一個塊的數據並發送一個塊的數據,直到把所有的數據都發送完。下面的例子就是采用這種方式的數據讀取和發送方式。源文件名為popen.c,代碼如下:
 
  1. #include <unistd.h>  
  2. #include <stdlib.h>  
  3. #include <stdio.h>  
  4. #include <string.h>  
  5. int main()  
  6. {  
  7. FILE *read_fp = NULL;  
  8. FILE *write_fp = NULL;  
  9. char buffer[BUFSIZ + 1];  
  10. int chars_read = 0;  
  11. //初始化緩沖區  
  12.     memset(buffer, '\0', sizeof(buffer));  
  13. //打開ls和grep進程  
  14.     read_fp = popen("ls -l", "r");  
  15.     write_fp = popen("grep rwxrwxr-x", "w");  
  16. //兩個進程都打開成功  
  17. if(read_fp && write_fp)  
  18.     {  
  19. //讀取一個數據塊  
  20.         chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp);  
  21. while(chars_read > 0)  
  22.         {  
  23.             buffer[chars_read] = '\0';  
  24. //把數據寫入grep進程  
  25.             fwrite(buffer, sizeof(char), chars_read, write_fp);  
  26. //還有數據可讀,循環讀取數據,直到讀完所有數據  
  27.             chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp);  
  28.         }  
  29. //關閉文件流  
  30.         pclose(read_fp);  
  31.         pclose(write_fp);  
  32.         exit(EXIT_SUCCESS);  
  33.     }  
  34.     exit(EXIT_FAILURE);  
  35. }  

3、popen的實現方式及優缺點

當請求popen調用運行一個程序時,它首先啟動shell,即系統中的sh命令,然后將command字符串作為一個參數傳遞給它。
這樣就帶來了一個優點和一個缺點。優點是:在Linux中所有的參數擴展都是由shell來完成的。所以在啟動程序(command中的命令程序)之前先啟動shell來分析命令字符串,也就可以使各種shell擴展(如通配符)在程序啟動之前就全部完成,這樣我們就可以通過popen啟動非常復雜的shell命令。
而它的缺點就是:對於每個popen調用,不僅要啟動一個被請求的程序,還要啟動一個shell,即每一個popen調用將啟動兩個進程,從效率和資源的角度看,popen函數的調用比正常方式要慢一些。
三、pipe調用
如果說popen是一個高級的函數,pipe則是一個底層的調用。與popen函數不同的是,它在兩個進程之間傳遞數據不需要啟動一個shell來解釋請求命令,同時它還提供對讀寫數據的更多的控制。
 
pipe函數的原型如下:
 
  1. #include <unistd.h>  
  2. int pipe(int file_descriptor[2]);  
我們可以看到pipe函數的定義非常特別,該函數在數組中牆上兩個新的文件描述符后返回0,如果返回返回-1,並設置errno來說明失敗原因。
 
數組中的兩個文件描述符以一種特殊的方式連接起來,數據基於先進先出的原則,寫到file_descriptor[1]的所有數據都可以從file_descriptor[0]讀回來。由於數據基於先進先出的原則,所以讀取的數據和寫入的數據是一致的。
 
特別提醒:
1、從函數的原型我們可以看到,它跟popen函數的一個重大區別是,popen函數是基於文件流(FILE)工作的,而pipe是基於文件描述符工作的,所以在使用pipe后,數據必須要用底層的read和write調用來讀取和發送。
 
2、不要用file_descriptor[0]寫數據,也不要用file_descriptor[1]讀數據,其行為未定義的,但在有些系統上可能會返回-1表示調用失敗。數據只能從file_descriptor[0]中讀取,數據也只能寫入到file_descriptor[1],不能倒過來。
 
例子:
首先,我們在原先的進程中創建一個管道,然后再調用fork創建一個新的進程,最后通過管道在兩個進程之間傳遞數據。源文件名為pipe.c,代碼如下:
 
  1. #include <unistd.h>  
  2. #include <stdlib.h>  
  3. #include <stdio.h>  
  4. #include <string.h>  
  5. int main()  
  6. {  
  7. int data_processed = 0;  
  8. int filedes[2];  
  9. const char data[] = "Hello pipe!";  
  10. char buffer[BUFSIZ + 1];  
  11.     pid_t pid;  
  12. //清空緩沖區  
  13.     memset(buffer, '\0', sizeof(buffer));  
  14. if(pipe(filedes) == 0)  
  15.     {  
  16. //創建管道成功  
  17. //通過調用fork創建子進程  
  18.         pid = fork();  
  19. if(pid == -1)  
  20.         {  
  21.             fprintf(stderr, "Fork failure");  
  22.             exit(EXIT_FAILURE);  
  23.         }  
  24. if(pid == 0)  
  25.         {  
  26. //子進程中  
  27. //讀取數據  
  28.             data_processed = read(filedes[0], buffer, BUFSIZ);  
  29.             printf("Read %d bytes: %s\n", data_processed, buffer);  
  30.             exit(EXIT_SUCCESS);  
  31.         }  
  32. else  
  33.         {  
  34. //父進程中  
  35. //寫數據  
  36.             data_processed = write(filedes[1], data, strlen(data));  
  37.             printf("Wrote %d bytes: %s\n", data_processed, data);  
  38. //休眠2秒,主要是為了等子進程先結束,這樣做也只是純粹為了輸出好看而已  
  39. //父進程其實沒有必要等等子進程結束  
  40.             sleep(2);  
  41.             exit(EXIT_SUCCESS);  
  42.         }  
  43.     }  
  44.     exit(EXIT_FAILURE);  
  45. }  
使用匿名管道,則通信的進程之間需要一個父子關系,通信的兩個進程一定是由一個共同的祖先進程啟動。但是匿名管道沒有上面說到的數據交叉的問題。 
與使用匿名管道相比,我們可以看到fifowrite.exe和fiforead.exe這兩個進程是沒有什么必然的聯系的

使用命名管道

一、什么是命名管道
命名管道也被稱為FIFO文件,它是一種特殊類型的文件,它在文件系統中以文件名的形式存在,但是它的行為卻和之前所講的沒有名字的管道(匿名管道)類似。
 
由於Linux中所有的事物都可被視為文件,所以對命名管道的使用也就變得與文件操作非常的統一,也使它的使用非常方便,同時我們也可以像平常的文件名一樣在命令中使用。
 
二、創建命名管道
我們可以使用兩下函數之一來創建一個命名管道,他們的原型如下:
 
 
  1. #include <sys/types.h>  
  2. #include <sys/stat.h>  
  3. int mkfifo(const char *filename, mode_t mode);  
  4. int mknod(const char *filename, mode_t mode | S_IFIFO, (dev_t)0);  
這兩個函數都能創建一個FIFO文件,注意是創建一個真實存在於文件系統中的文件,filename指定了文件名,而mode則指定了文件的讀寫權限。
 
mknod是比較老的函數,而使用mkfifo函數更加簡單和規范,所以建議在可能的情況下,盡量使用mkfifo而不是mknod。
 
三、訪問命名管道
 
1、打開FIFO文件
與打開其他文件一樣,FIFO文件也可以使用open調用來打開。注意,mkfifo函數只是創建一個FIFO文件,要使用命名管道還是將其打開。
 
但是有兩點要注意,1、就是程序不能以O_RDWR模式打開FIFO文件進行讀寫操作,而其行為也未明確定義,因為如一個管道以讀/寫方式打開,進程就會讀回自己的輸出,同時我們通常使用FIFO只是為了單向的數據傳遞。2、就是傳遞給open調用的是FIFO的路徑名,而不是正常的文件。
 
打開FIFO文件通常有四種方式,
 
 
  1. open(const char *path, O_RDONLY);//1  
  2. open(const char *path, O_RDONLY | O_NONBLOCK);//2  
  3. open(const char *path, O_WRONLY);//3  
  4. open(const char *path, O_WRONLY | O_NONBLOCK);//4  
在open函數的調用的第二個參數中,你看到一個陌生的選項O_NONBLOCK,選項O_NONBLOCK表示非阻塞,加上這個選項后,表示open調用是非阻塞的,如果沒有這個選項,則表示open調用是阻塞的。
 
open調用的阻塞是什么一回事呢?很簡單,對於以只讀方式(O_RDONLY)打開的FIFO文件,如果open調用是阻塞的(即第二個參數為O_RDONLY),除非有一個進程以寫方式打開同一個FIFO,否則它不會返回;如果open調用是非阻塞的的(即第二個參數為O_RDONLY | O_NONBLOCK),則即使沒有其他進程以寫方式打開同一個FIFO文件,open調用將成功並立即返回。
 
對於以只寫方式(O_WRONLY)打開的FIFO文件,如果open調用是阻塞的(即第二個參數為O_WRONLY),open調用將被阻塞,直到有一個進程以只讀方式打開同一個FIFO文件為止;如果open調用是非阻塞的(即第二個參數為O_WRONLY | O_NONBLOCK),open總會立即返回,但如果沒有其他進程以只讀方式打開同一個FIFO文件,open調用將返回-1,並且FIFO也不會被打開。
 
四、使用FIFO實現進程間的通信
說了這么多,下面就用一個例子程序來說明一下,兩個進程如何通過FIFO實現通信吧。這里有兩個源文件,一個fifowrite.c,它在需要時創建管道,然后向管道寫入數據,數據由文件Data.txt提供,大小為10M,內容全是字符‘0’。另一個源文件為fiforead.c,它從FIFO中讀取數據,並把讀到的數據保存到另一個文件DataFormFIFO.txt中。為了讓程序更加簡潔,忽略了有些函數調用是否成功的檢查。
 
fifowrite.c的源代碼如下:
 
  1. #include <unistd.h>  
  2. #include <stdlib.h>  
  3. #include <fcntl.h>  
  4. #include <limits.h>  
  5. #include <sys/types.h>  
  6. #include <sys/stat.h>  
  7. #include <stdio.h>  
  8. #include <string.h>  
  9.   
  10. int main()  
  11. {  
  12.     const char *fifo_name = "/tmp/my_fifo";  
  13.     int pipe_fd = -1;  
  14.     int data_fd = -1;  
  15.     int res = 0;  
  16.     const int open_mode = O_WRONLY;  
  17.     int bytes_sent = 0;  
  18.     char buffer[PIPE_BUF + 1];  
  19.   
  20.     if(access(fifo_name, F_OK) == -1)  
  21.     {  
  22.         //管道文件不存在  
  23.         //創建命名管道  
  24.         res = mkfifo(fifo_name, 0777);  
  25.         if(res != 0)  
  26.         {  
  27.             fprintf(stderr, "Could not create fifo %s\n", fifo_name);  
  28.             exit(EXIT_FAILURE);  
  29.         }  
  30.     }  
  31.   
  32.     printf("Process %d opening FIFO O_WRONLY\n", getpid());  
  33.     //以只寫阻塞方式打開FIFO文件,以只讀方式打開數據文件  
  34.     pipe_fd = open(fifo_name, open_mode);  
  35.     data_fd = open("Data.txt", O_RDONLY);  
  36.     printf("Process %d result %d\n", getpid(), pipe_fd);  
  37.   
  38.     if(pipe_fd != -1)  
  39.     {  
  40.         int bytes_read = 0;  
  41.         //向數據文件讀取數據  
  42.         bytes_read = read(data_fd, buffer, PIPE_BUF);  
  43.         buffer[bytes_read] = '\0';  
  44.         while(bytes_read > 0)  
  45.         {  
  46.             //向FIFO文件寫數據  
  47.             res = write(pipe_fd, buffer, bytes_read);  
  48.             if(res == -1)  
  49.             {  
  50.                 fprintf(stderr, "Write error on pipe\n");  
  51.                 exit(EXIT_FAILURE);  
  52.             }  
  53.             //累加寫的字節數,並繼續讀取數據  
  54.             bytes_sent += res;  
  55.             bytes_read = read(data_fd, buffer, PIPE_BUF);  
  56.             buffer[bytes_read] = '\0';  
  57.         }  
  58.         close(pipe_fd);  
  59.         close(data_fd);  
  60.     }  
  61.     else  
  62.         exit(EXIT_FAILURE);  
  63.   
  64.     printf("Process %d finished\n", getpid());  
  65.     exit(EXIT_SUCCESS);  
  66. }  
源文件fiforead.c的代碼如下:
 
  1. #include <unistd.h>  
  2. #include <stdlib.h>  
  3. #include <stdio.h>  
  4. #include <fcntl.h>  
  5. #include <sys/types.h>  
  6. #include <sys/stat.h>  
  7. #include <limits.h>  
  8. #include <string.h>  
  9. int main()  
  10. {  
  11. const char *fifo_name = "/tmp/my_fifo";  
  12. int pipe_fd = -1;  
  13. int data_fd = -1;  
  14. int res = 0;  
  15. int open_mode = O_RDONLY;  
  16. char buffer[PIPE_BUF + 1];  
  17. int bytes_read = 0;  
  18. int bytes_write = 0;  
  19. //清空緩沖數組  
  20.     memset(buffer, '\0', sizeof(buffer));  
  21.     printf("Process %d opening FIFO O_RDONLY\n", getpid());  
  22. //以只讀阻塞方式打開管道文件,注意與fifowrite.c文件中的FIFO同名  
  23.     pipe_fd = open(fifo_name, open_mode);  
  24. //以只寫方式創建保存數據的文件  
  25.     data_fd = open("DataFormFIFO.txt", O_WRONLY|O_CREAT, 0644);  
  26.     printf("Process %d result %d\n",getpid(), pipe_fd);  
  27. if(pipe_fd != -1)  
  28.     {  
  29. do  
  30.         {  
  31. //讀取FIFO中的數據,並把它保存在文件DataFormFIFO.txt文件中  
  32.             res = read(pipe_fd, buffer, PIPE_BUF);  
  33.             bytes_write = write(data_fd, buffer, res);  
  34.             bytes_read += res;  
  35.         }while(res > 0);  
  36.         close(pipe_fd);  
  37.         close(data_fd);  
  38.     }  
  39. else  
  40.         exit(EXIT_FAILURE);  
  41.     printf("Process %d finished, %d bytes read\n", getpid(), bytes_read);  
  42.     exit(EXIT_SUCCESS);  
  43. }  

但是為了數據的安全,我們很多時候要采用阻塞的FIFO,讓寫操作變成原子操作。


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM