2. 程式人生 > >C/C++ 進程間通信 管道

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

阿新 • • 發佈：2017-08-22
先進先出 rdo sys ring 指定 進程間通信 存在 另一個 don

使用匿名管道

一、什麽是管道 如果你使用過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>
  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];
  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. }
  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);
  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);
  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，讓寫操作變成原子操作。

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

相關推薦

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

先進先出 rdo sys ring 指定 進程間通信 存在 另一個 don 使用匿名管道 一、什麽是管道 如果你使用過Linux的命令，那麽對於管道這個名詞你一定不會感覺到陌生，因為我們通常通過符號“|"來使用管道，但是管理的真正定義是什麽呢？管道是一個進程連接數據流到另一

C winapi 進程間通信(Named Pipe)。

winapi none code 技術分享 seh adb eth rcm fun 要求實現： 用命名管道的相關知識及函數，分別編寫服務器進程和客戶端進程程序。 要求服務器進程和客戶端進程程序能夠通過互相傳送數據。 當服務器進程和客戶端進程中的任何一端輸入“end”時，結

c/c++ linux 進程間通信系列3，使用socketpair，pipe

dup nis 讀取數據 out ets har memset https %s linux 進程間通信系列3，使用socketpair，pipe 1，使用socketpair，實現進程間通信，是雙向的。 2，使用pipe，實現進程間通信 使用pipe關鍵點：fd[0

c/c++ linux 進程間通信系列7，使用pthread mutex

shm delete clu wait 進程間通信 pro -m printf gre linux 進程間通信系列7，使用pthread mutex #include <stdio.h> #include <stdlib.h> #include &

Linux進程間通信--管道

Linux進程間通信---管道

stdlib.h 另一個 得到 stat 輸入 for 特定 exist cat IPC： IPC，即Inter-Process Communication，進程間通信。是進程間通信的對象，包括管道、消息隊列、信號量、套接字等。關於IPC結構，首先IPC結構是內核維護的

C++進程間通信方式

ready EDA 空間 cati pbo 消息傳遞 adf 操作 .com https://www.cnblogs.com/swunield/articles/3893250.html 進程通常被定義為一個正在運行的程序的實例，它由兩個部分組成：　　一個是操作系統用來管

簡述Linux進程間通信之命名管道FIFO

error pri include mask urn mode linux 系統 sizeof 　　上文聊到管道(pipe),可以使有親緣關系的進程間進行通信. 　　對於沒有親緣關系的進程如何通信?本文來聊一聊命名管道FIFO. 一、概念 　　命名管道FIFO,提供一個路徑

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

命名 som 新的 ima fcntl node hello 字符串 oot 無名管道(pipe) 管道可用於具有親緣關系進程間的通信，有名管道克服了管道沒有名字的限制，因此，除具有管道所具有的功能外，它還允許無親緣關系進程間的通信； 定義函數： int pipe（int

Linux進程間通信之管道(pipe)、命名管道(FIFO)與信號(Signal)

阻塞 node include 系統 types.h 標準 div [0 pipe 整理自網絡 Unix IPC包括：管道(pipe)、命名管道(FIFO)與信號(Signal) 管道(pipe) 管道可用於具有親緣關系進程間的通信，有名管道克服了管道沒有名字的

查漏補缺：進程間通信（IPC）：管道

文件 lap ipc spl ont unix aps class std 　　管道是UNIX系統IPC的最古老形式，所有UNIX系統都提供此種通信機制。管道有以下兩種局限性： 　　（1）歷史上，管道是半雙工的（即數據只能在一個方向上流動）。 　　（2）管道只能在具有公共先

進程間通信：管道(1)

and 文件流 命令 code 傳遞 設置 特殊 可用 數組的指針 一、管道 　　當從一個進程連接數據流到另一個進程時，我們使用術語管道（pipe）。我們通常是把一個進程的輸出通過管道連接到另一個進程的輸入。對於shell命令來說，命令的連接是通過管道字符來完成的，如：cm

Python之進程同步控制（鎖信號量事件 ）、進程間通信——隊列和管道

load 很快 容器 數據安全 全部 傳遞 幫我 之前 引入 進程同步(multiprocess.Lock、multiprocess.Semaphore、multiprocess.Event) 鎖 —— multiprocess.Lock 通過剛剛的學習，我們千方百計實現了

利用管道實現進程間通信

Linux 進程 管道 通信 管道通信 匿名管道 創建匿名管道 int pipe(int pipefd[2]);pipefd[0] : 表示讀管道pipefd[1] : 表示寫管道返回 0表示成功，非零表示創建失敗。 代碼事例: //匿名管道

進程間通信：管道

bash usr ++ target span pes nvi 其中 pre 任務：實現一個類bash的管道符功能程序，可以通過特殊符號例如‘@’將第一個程序的輸出作為第二個程序的輸入。 大體思路： 1. 主進程創建一個管道，得到一對讀寫fd[2

st_vio——進程間通信接口抽象結構體

sock 註釋 windows系統 out rip peer 如果 ifd end 工作忙，學習忙，但還是得隨便寫點。 st_vio，顧名思義，應該是指virtual IO，即虛擬IO。根據代碼裏的註釋，這個是一個高度抽象的進程間通信接口結構體，mysql中，如果不是用C+

轉Android進程間通信（IPC）機制Binder簡要介紹和學習計劃

trac named 組成 get tle 能力 計劃 英文 其中 轉自：http://blog.csdn.net/luoshengyang/article/details/6618363/ 在Android系統中，每一個應用程序都是由一些Activity和Ser

進程間通信——消息隊列

如果 blank sof 標識 tro 相同 聯系 ron 流浪 1. IPC標識符： 　　每一個I P C目標都有一個唯一的I P C標識符。這裏所指的I P C目標是指一個單獨的消息隊列、一個信號量集或者一個共享的內存段。系統內核使用此標識符在系統內核中指明 I P C

APUE：進程間通信

操作 wait shmdt 半雙工 信號 apue highlight mod 需要 管道 半雙工。一般由父進程創建，用於父子進程間、子進程間通信。匿名，一對一。 // fd[0] 只讀 // fd[1] 只寫 int pipe (int fd[2]); 簡單執行命令

APUE：高級進程間通信

creat conn 核心 sockets desc returns protocol type sin 這一章核心內容：使用 UNIX 域套接字傳送文件描述符。 /* Create two new sockets, of type TYPE in domain DO