linux環境編程(2): 使用pipe完成進程間通信

来源:https://www.cnblogs.com/kfggww/archive/2023/01/24/17066291.html
-Advertisement-
Play Games

1. 寫在前面 linux系統內核為上層應用程式提供了多種進程間通信(IPC)的手段，適用於不同的場景，有些解決進程間數據傳遞的問題，另一些則解決進程間的同步問題。對於同樣一種IPC機制，又有不同的API供應用程式使用，目前有POSIX IPC以及System V IPC可以為應用程式提供服務。後續 ...


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, 思考結束，來看看管道加多進程版本的質數生成器演算法思路：

prime-number-pipe

這個“質數篩子”中的每個進程主要有三個任務，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方法實現一個小項目，有想法的歡迎在評論區冒泡。

6. 相關鏈接

本文來自博客園，作者：kfggww，轉載請註明原文鏈接：https://www.cnblogs.com/kfggww/p/17066291.html


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 《RPC實戰與核心原理》學習筆記Day6
    RPC基本框架包括四個模塊：傳輸模塊、協議模塊、集群模塊以及Bootstrap模塊。 我們可以使用插件化架構的方法來擴展RPC基本框架，使其更加靈活適應將來可能得變更。 ...
  • 通用8位SPI介面模塊——verilog實現
    本次設計一個八位的SPI的介面模塊，可以修改輸出的頻率，也可以通過修改參數來設置通信模式。 本模塊是設定生成一個目標輸出頻率的二倍的計數器，然後通關計數的值來輸出響應的信號，從而進行SPI通信。 本模塊既可以發送數據也可以接收數據，給Send_en信號使開始發送數據，在接收到8位數據後會生成Read ...
  • 學習筆記——Liunx中CentOS中的有關（network）的命令；其他命令；關機重啟命令
    2023-01-23 一、network的命令 （1）關閉網路 systemctl stop network （2）查看網路狀態 systemctl status network （3）開啟網路 systemctl start network （4）重新啟動網路 systemctl start ne ...
  • System
    System類 exit：退出當前程式。 arraycopy：複製數組元素，比較適合底層調用，一般使用Arrays.copyOF完成複製數組。 currentTimeMillens：返回當前時間距離 1970-1-1 的毫秒數。 gc：運行垃圾回收機制 System.gc(); public cla ...
  • 財務精度：BigInteger 與 BigDecimal
    財務精度：BigInteger 與 BigDecimal 每博一文案 師父說: 人這一輩子，真地好難。 有些人，好著好著，忽然就變陌生了，有些手，牽著牽著，瞬間就放開了，有些路，走著走著，就失去了方向了。 懵懵懂懂，一眨眼，我們就長大了，愛過的人，一轉身，，青春就溜走了。以為有來日方長的，最後只剩人 ...
  • 學習筆記——Liunx；Linux文件與目錄結構；VI/VIM編輯器（一般模式、編輯模式、命令模式）
    2023-01-23 一、Linux 1、Liunx的簡介 Linux是一套免費使用和自用傳播的類Unix操作系統，是一個基於POSIX和UNIX的多用戶、多任務、支持多線程和多CPU的操作系統。Linux能運行主要的UNIX工具軟體、應用程式和網路協議。它支持32位和64位硬體。Linux繼承了U ...
  • RHCE01-Redhat 8 的安裝和初始配置
    Redhat 8 的安裝和初始配置 環境說明： 1.在VMWare Workstation上創建虛擬機安裝RHEL 8先決條件：自己的物理機（電腦/工作站/伺服器）的CPU的虛擬化功能要開啟。Intel的CPU：Virtualization Technology（VT-x）AMD的CPU：SVM M ...
  • 微機原理與系統設計筆記2 | 8086CPU結構與功能
    打算整理彙編語言與介面微機這方面的學習記錄。本部分講解8086CPU的結構和基本功能以及特性。 參考資料 西電《微機原理與系統設計》周佳社 西交《微機原理與介面技術》 課本《彙編語言與介面技術》王讓定 小甲魚《彙編語言》 1. 微處理器的外部結構 1.1 引腳 外部結構就是封裝出來的輸入輸出引腳。8 ...
一周排行
    -Advertisement-
    Play Games
  • （開源）都進來！簡單易懂、功能強大的許可權+可視化流程管理系統
    1、預覽地址：http://139.155.137.144:9012 2、qq群:801913255 一、前言 隨著網路的發展，企業對於信息系統數據的保密工作愈發重視，不同身份、角色對於數據的訪問許可權都應該大相徑庭。 列如 1、不同登錄人員對一個數據列表的可見度是不一樣的，如數據列、數據行、數據按鈕 ...
  • 設計模式-C#實現簡單工廠模式
    前言 上一篇文章寫瞭如何使用RabbitMQ做個簡單的發送郵件項目，然後評論也是比較多，也是準備去學習一下如何確保RabbitMQ的消息可靠性，但是由於時間原因，先來說說設計模式中的簡單工廠模式吧！ 在瞭解簡單工廠模式之前，我們要知道C#是一款面向對象的高級程式語言。它有3大特性，封裝、繼承、多態。 ...
  • Nodify學習 一：介紹與使用
    Nodify學習 一：介紹與使用 - 可樂_加冰 - 博客園 (cnblogs.com) Nodify學習 二：添加節點 - 可樂_加冰 - 博客園 (cnblogs.com) 介紹 Nodify是一個WPF基於節點的編輯器控制項，其中包含一系列節點、連接和連接器組件，旨在簡化構建基於節點的工具的過程 ...
  • 使用C#/.NET解析Wiki百科數據實現獲取歷史上的今天
    創建一個webapi項目做測試使用。 創建新控制器，搭建一個基礎框架，包括獲取當天日期、wiki的請求地址等 創建一個Http請求幫助類以及方法，用於獲取指定URL的信息 使用http請求訪問指定url，先運行一下，看看返回的內容。內容如圖右邊所示，實際上是一個Json數據。我們主要解析 大事記 部 ...
  • .NET科普：.NET簡史、.NET Standard以及C#和.NET Framework之間的關係
    最近在不少自媒體上看到有關.NET與C#的資訊與評價，感覺大家對.NET與C#還是不太瞭解，尤其是對2016年6月發佈的跨平臺.NET Core 1.0，更是知之甚少。在考慮一番之後，還是決定寫點東西總結一下，也回顧一下.NET的發展歷史。 首先，你沒看錯，.NET是跨平臺的，可以在Windows、 ...
  • Nodify學習 二：添加節點
    Nodify學習 一：介紹與使用 - 可樂_加冰 - 博客園 (cnblogs.com) Nodify學習 二：添加節點 - 可樂_加冰 - 博客園 (cnblogs.com) 添加節點（nodes） 通過上一篇我們已經創建好了編輯器實例現在我們為編輯器添加一個節點 添加model和viewmode ...
  • 論如何直接用EF Core實現創建更新時間、用戶審計，自動化樂觀併發、軟刪除和樹形查詢（上）
    前言 資料庫併發，數據審計和軟刪除一直是數據持久化方面的經典問題。早些時候，這些工作需要手寫複雜的SQL或者通過存儲過程和觸發器實現。手寫複雜SQL對軟體可維護性構成了相當大的挑戰，隨著SQL字數的變多，用到的嵌套和複雜語法增加，可讀性和可維護性的難度是幾何級暴漲。因此如何在實現功能的同時控制這些S ...
  • C# 使用模式匹配的好處,因為好用所以推薦~
    類型檢查和轉換：當你需要檢查對象是否為特定類型，並且希望在同一時間內將其轉換為那個類型時，模式匹配提供了一種更簡潔的方式來完成這一任務，避免了使用傳統的as和is操作符後還需要進行額外的null檢查。 複雜條件邏輯：在處理複雜的條件邏輯時，特別是涉及到多個條件和類型的情況下，使用模式匹配可以使代碼更 ...
  • 推薦一種批量判斷文件是否存在的快速辦法
    在日常開發中，我們經常需要和文件打交道，特別是桌面開發，有時候就會需要載入大批量的文件，而且可能還會存在部分文件缺失的情況，那麼如何才能快速的判斷文件是否存在呢？如果處理不當的，且文件數量比較多的時候，可能會造成卡頓等情況，進而影響程式的使用體驗。今天就以一個簡單的小例子，簡述兩種不同的判斷文件是否... ...
  • 論如何直接用EF Core實現創建更新時間、用戶審計，自動化樂觀併發、軟刪除和樹形查詢（中）
    前言 資料庫併發，數據審計和軟刪除一直是數據持久化方面的經典問題。早些時候，這些工作需要手寫複雜的SQL或者通過存儲過程和觸發器實現。手寫複雜SQL對軟體可維護性構成了相當大的挑戰，隨著SQL字數的變多，用到的嵌套和複雜語法增加，可讀性和可維護性的難度是幾何級暴漲。因此如何在實現功能的同時控制這些S ...
所有分類