Linux C編程之十一 進程間通信

一、整體大綱

二、進程間通信概念及方法

       Linux環境下，進程地址空間相互獨立，每個進程各自有不同的用戶地址空間。任何一個進程的全局變量在另一個進程中都看不到，所以進程和進程之間不能相互訪問，要交換數據必須通過內核，在內核中開辟一塊緩沖區，進程1把數據從用戶空間拷到內核緩沖區，進程2再從內核緩沖區把數據讀走，內核提供的這種機制稱為進程間通信（IPC，InterProcess Communication）。 

       在進程間完成數據傳遞需要借助操作系統提供特殊的方法，如：文件、管道、信號、共享內存、消息隊列、套接字、命名管道等。隨着計算機的蓬勃發展，一些方法由於自身設計缺陷被淘汰或者棄用。現今常用的進程間通信方式有：

       1）管道 (使用最簡單)

       2）信號 (開銷最小)

       3）共享映射區 (無血緣關系)

       4）本地套接字 (最穩定)

三、進程間通信方法介紹

1. 管道

    （1）管道的概念：

    管道是一種最基本的IPC機制，作用於有血緣關系的進程之間，完成數據傳遞。調用pipe系統函數即可創建一個管道。有如下特質：

    1） 其本質是一個偽文件(實為內核緩沖區)

    2）由兩個文件描述符引用，一個表示讀端，一個表示寫端。

    3） 規定數據從管道的寫端流入管道，從讀端流出。

    管道的原理: 管道實為內核使用環形隊列機制，借助內核緩沖區(4k)實現。

    管道的局限性：

    1） 數據一旦被讀走，便不在管道中存在，不可反復讀取。

    2） 由於管道采用半雙工通信方式。因此，數據只能在一個方向上流動。

    3） 只能在有公共祖先的進程間使用管道。

    常見的通信方式有，單工通信、半雙工通信、全雙工通信。

    （2）管道相關函數

    創建管道

    int pipe(int pipefd[2]);               成功：0；失敗：-1，設置errno

    函數調用成功返回r/w兩個文件描述符。無需open，但需手動close。規定：fd[0] → r； fd[1] → w，就像0對應標准輸入，1對應標准輸出一樣。向管道文件讀寫數據其實是在讀寫內核緩沖區。

    管道創建成功以后，創建該管道的進程（父進程）同時掌握着管道的讀端和寫端。如何實現父子進程間通信呢？通常可以采用如下步驟： 

    1）父進程調用pipe函數創建管道，得到兩個文件描述符fd[0]、fd[1]指向管道的讀端和寫端。

    2）父進程調用fork創建子進程，那么子進程也有兩個文件描述符指向同一管道。

    3）父進程關閉管道讀端，子進程關閉管道寫端。父進程可以向管道中寫入數據，子進程將管道中的數據讀出。由於管道是利用環形隊列實現的，數據從寫端流入管道，從讀端流出，這樣就實現了進程間通信。

練習：父子進程使用管道通信，父寫入字符串，子進程讀出並打印到屏幕？

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main()
{
    int fd[2];
    pipe(fd);
    pid_t pid = fork();

    if (pid == 0)
    {
        //子進程關閉寫端
        close(fd[1]);
        char buf[256] = {0};
        while(1)
        {
            memset(buf, 0, sizeof(buf));
            int ret = read(fd[0], buf, sizeof(buf));
            if (ret == 0)
            {
                printf("read over!\n");
                break;
            }
            else if(ret > 0)
            {
                write(STDOUT_FILENO,buf,ret);
            }
        }
    }
    else if (pid > 0)
    {
        //父進程關閉讀端
        close(fd[0]);
        char buf[256] = {0};
        int num = 0;
        while(1)
        {
            memset(buf, 0, sizeof(buf));
            sprintf(buf, "data from parent %d\n", num++);
            write(fd[1], buf, sizeof(buf));
            sleep(1);
        }
    }

    return 0;
}

    （3）管道的讀寫行為

    使用管道需要注意以下4種特殊情況（假設都是阻塞I/O操作，沒有設置O_NONBLOCK標志）：

    1）如果所有指向管道寫端的文件描述符都關閉了（管道寫端引用計數為0），而仍然有進程從管道的讀端讀數據，那么管道中剩余的數據都被讀取后，再次read會返回0，就像讀到文件末尾一樣。

    2） 如果有指向管道寫端的文件描述符沒關閉（管道寫端引用計數大於0），而持有管道寫端的進程也沒有向管道中寫數據，這時有進程從管道讀端讀數據，那么管道中剩余的數據都被讀取后，再次read會阻塞，直到管道中有數據可讀了才讀取數據並返回。

    3）如果所有指向管道讀端的文件描述符都關閉了（管道讀端引用計數為0），這時有進程向管道的寫端write，那么該進程會收到信號SIGPIPE，通常會導致進程異常終止。當然也可以對SIGPIPE信號實施捕捉，不終止進程。具體方法信號章節詳細介紹。

    4）如果有指向管道讀端的文件描述符沒關閉（管道讀端引用計數大於0），而持有管道讀端的進程也沒有從管道中讀數據，這時有進程向管道寫端寫數據，那么在管道被寫滿時再次write會阻塞，直到管道中有空位置了才寫入數據並返回。

    總結：

    1）讀管道：  1. 管道中有數據，read返回實際讀到的字節數。

                          2. 管道中無數據：

                             (1) 管道寫端被全部關閉，read返回0 (好像讀到文件結尾)

                             (2) 寫端沒有全部被關閉，read阻塞等待(不久的將來可能有數據遞達，此時會讓出cpu)

    2）寫管道：  1. 管道讀端全部被關閉， 進程異常終止(也可使用捕捉SIGPIPE信號，使進程不終止)

                          2. 管道讀端沒有全部關閉：

                             (1) 管道已滿，write阻塞。

                             (2) 管道未滿，write將數據寫入，並返回實際寫入的字節數。

    練習1：使用管道實現父子進程間通信，完成：ls | wc -l。假定父進程實現ls，子進程實現wc？

                 注意：ls命令正常會將結果集寫出到stdout，但現在會寫入管道的寫端；wc -l 正常應該從stdin讀取數據，但此時會從管道的讀端讀。

#include <stdio.h>
#include <unistd.h>

int main()
{
    int fd[2];
    pipe(fd);

    pid_t pid = fork();
    if(pid == 0){
        //son
        //son -- > ls
        //關閉 寫端
        close(fd[1]);
        //1. 先重定向
        dup2(fd[0], STDIN_FILENO);//標准輸入重定向到管道寫端
        //2. execlp
        execlp("wc","wc","-l",NULL);
    }else if(pid > 0){
        //parent
        //關閉讀端
        close(fd[0]);
        //1. 先重定向，標准輸出重定向到管道讀端
        dup2(fd[1], STDOUT_FILENO);
        //2. execlp
        execlp("ls","ls",NULL);
    }

    return 0;
}

#include <stdio.h>
#include <unistd.h>

int main()
{
    int fd[2];
    pipe(fd);

    pid_t pid = fork();
    if(pid == 0){
        //son 
        //son -- > ps 
        //關閉 讀端
        close(fd[0]);
        //1. 先重定向
        dup2(fd[1],STDOUT_FILENO);//標准輸出重定向到管道寫端
        //2. execlp 
        execlp("ps","ps","aux",NULL);
    }else if(pid > 0){
        //parent
        //關閉寫端
        close(fd[1]);
        //1. 先重定向，標准輸入重定向到管道讀端
        dup2(fd[0],STDIN_FILENO);
        //2. execlp 
        execlp("grep","grep","bash",NULL);
    }

    return 0;
}

執行結果分析：程序執行，發現程序執行結束，shell還在阻塞等待用戶輸入。這是因為，shell → fork → ./pipe2， 程序pipe2的子進程將stdin重定向給管道，父進程執行的ls會將結果集通過管道寫給子進程。若父進程在子進程打印wc的結果到屏幕之前被shell調用wait回收，shell就會先輸出$提示符。

    練習2：使用管道實現兄弟進程間通信。 兄：ls  弟： wc -l  父：等待回收子進程？要求，使用“循環創建N個子進程”模型創建兄弟進程，使用循環因子i標示。注意管道讀寫行為。

實現思路：父進程關閉讀寫端，兩個子進程，一個關閉管道的讀端去寫，一個關閉管道的寫端去讀。

#include <stdio.h>
#include <unistd.h>

int main()
{
    int fd[2];
    pid_t pid;
    int n = 2, i = 0;
    pipe(fd);

    for (i = 0; i < n; i++)
    {
        pid = fork();
        if (pid == 0)
        {
            break;
        }
    }

    //兄弟進程
    if (i == 0)
    {
        printf("Brother1 pid = %d, ppid = %d\n", getpid(), getppid());
        //1. 關閉寫端
        close(fd[1]);
        //2. 先重定向
        dup2(fd[0], STDIN_FILENO);//標准輸入重定向到管道寫端
        //3. 執行execlp
        execlp("wc","wc","-l",NULL);

    }
    //兄弟進程
    else if (i == 1)
    {
        printf("Brother2 pid = %d, ppid = %d\n", getpid(), getppid());
        //1. 關閉讀端
        close(fd[0]);
        //2. 先重定向，標准輸出重定向到管道讀端
        dup2(fd[1], STDOUT_FILENO);
        //3. execlp
        execlp("ls","ls",NULL);

    }

    else if (i == 2)
    {
        //parent
        //父親需要關閉讀寫兩端
        close(fd[0]);
        close(fd[1]);
        //回收子進程
        wait(NULL);
        wait(NULL);
    }

    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
    int fd[2];
    pipe(fd);
    pid_t pid;
    int n =2,i = 0;
    for(i = 0; i < n; i ++){
        pid = fork();
        if(pid == 0){
            break;
        }
    }

    //i = 0 ,代表兄長，1 - 代表弟弟，2- 父親
    if(i == 0){
        //兄長進程
        //1. 關閉讀端
        close(fd[0]);
        //2. 重定向
        dup2(fd[1],STDOUT_FILENO);
        //3. 執行 execlp
        execlp("ps","ps","aux",NULL);
            
    }else if(i == 1){
        //弟弟 
        //1. 關閉寫端
        close(fd[1]);
        //2. 重定向
        dup2(fd[0],STDIN_FILENO);
        //3. 執行ececlp
        execlp("grep","grep","bash",NULL);

    }else if(i == 2){
        //parent 
        //父親需要關閉讀寫兩端
        close(fd[0]);
        close(fd[1]);
        //回收子進程
        wait(NULL);
        wait(NULL);
    }


    return 0;
}

    測試：是否允許，一個pipe有一個寫端多個讀端呢？是否允許有一個讀端多個寫端呢？

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main()
{
    int fd[2];
    pid_t pid;
    int n = 3, i = 0;
    pipe(fd);

    for (i = 0; i < n; i++)
    {
        pid = fork();
        if (pid == 0)
        {
            break;
        }
    }

    //兄弟進程
    if (i == 0)
    {
        printf("Brother1 pid = %d, ppid = %d\n", getpid(), getppid());
        //1. 關閉寫端
        close(fd[1]);
        //2. 先重定向
        dup2(fd[0], STDIN_FILENO);//標准輸入重定向到管道寫讀端
        //3. 執行execlp
        char buf[256] = {0};
        while(1)
        {
            memset(buf, 0, sizeof(buf));
            int ret =  read(fd[0], buf, sizeof(buf));
            if (ret == 0)
            {
                printf("read over");
                break;
            }
        }
    }

    //兄弟進程
    else if (i == 1)
    {
        printf("Brother2 pid = %d, ppid = %d\n", getpid(), getppid());
        //1. 關閉讀端
        close(fd[1]);
        //2. 先重定向，標准輸出重定向到管道讀端
        dup2(fd[0], STDIN_FILENO);
        char buf[256] = {0};
        while(1)
        {
            memset(buf, 0, sizeof(buf));
            int ret =  read(fd[0], buf, sizeof(buf));
            if (ret == 0)
            {
                printf("read over");
                break;
            }
        }
    }
    //兄弟進程
    else if (i == 2)
    {
        printf("Brother3 pid = %d, ppid = %d\n", getpid(), getppid());
        //1. 關閉讀端
        close(fd[0]);
        //2. 先重定向，標准輸出重定向到管道讀端
        dup2(fd[1], STDOUT_FILENO);
        //3. 寫數據到寫端
        int num = 0;
        char buf[256] = {0};
        while(1)
        {
            memset(buf, 0, sizeof(buf));
            sprintf(buf, "from broth3 %d\n", num++);
            int ret = write(fd[1], buf, sizeof(buf));
            if (ret == -1)
            {
                perror("write err:");
                break;
            }
            sleep(1);
        }
    }
   else if (i == 3)
    {
        //parent
        //父親需要關閉讀寫兩端
        close(fd[0]);
        close(fd[1]);
        //回收子進程
        wait(NULL);
        wait(NULL);
        wait(NULL);
    }

    return 0;
}

結論：一個讀多個寫會hang住。

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main()
{
    int fd[2];
    pid_t pid;
    int n = 3, i = 0;
    pipe(fd);

    for (i = 0; i < n; i++)
    {
        pid = fork();
        if (pid == 0)
        {
            break;
        }
    }

    //兄弟進程
    if (i == 0)
    {
        printf("Brother1 pid = %d, ppid = %d\n", getpid(), getppid());
        //1. 關閉寫端
        close(fd[1]);
        //2. 先重定向
        dup2(fd[0], STDIN_FILENO);//標准輸入重定向到管道寫讀端
        //3. 執行execlp
        char buf[256] = {0};
        while(1)
        {
            memset(buf, 0, sizeof(buf));
            int ret =  read(fd[0], buf, sizeof(buf));
            if (ret == 0)
            {
                printf("read over");
                break;
            }
        }
    }
    //兄弟進程
    else if (i == 1)
    {
        printf("Brother2 pid = %d, ppid = %d\n", getpid(), getppid());
        //1. 關閉讀端
        close(fd[0]);
        //2. 先重定向，標准輸出重定向到管道讀端
        dup2(fd[1], STDOUT_FILENO);
        int num = 0;
        char buf[256] = {0};
        while(1)
        {
            memset(buf, 0, sizeof(buf));
            sprintf(buf, "from broth2 %d\n", num++);
            int ret = write(fd[1], buf, sizeof(buf));
            if (ret == -1)
            {
                perror("write err:");
                break;
            }
            sleep(1);
        }
    }
    //兄弟進程
    else if (i == 2)
    {
        printf("Brother3 pid = %d, ppid = %d\n", getpid(), getppid());
        //1. 關閉讀端
        close(fd[0]);
        //2. 先重定向，標准輸出重定向到管道讀端
        dup2(fd[1], STDOUT_FILENO);
        //3. 寫數據到寫端
        int num = 0;
        char buf[256] = {0};
        while(1)
        {
            memset(buf, 0, sizeof(buf));
            sprintf(buf, "from broth3 %d\n", num++);
            int ret = write(fd[1], buf, sizeof(buf));
            if (ret == -1)
            {
                perror("write err:");
                break;
            }
            sleep(1);
        }
    }
    else if (i == 3)
    {
        //parent
        //父親需要關閉讀寫兩端
        close(fd[0]);
        close(fd[1]);
        //回收子進程
        wait(NULL);
        wait(NULL);
        wait(NULL);
    }

    return 0;
}

結論：一個寫多個讀會hang住。

    （4）管道緩沖區大小

    可以使用ulimit -a 命令來查看當前系統中創建管道文件所對應的內核緩沖區大小。通常為：

pipe size            (512 bytes, -p) 8

    也可以使用fpathconf函數，借助參數        選項來查看。使用該宏應引入頭文件<unistd.h>

    long fpathconf(int fd, int name);      成功：返回管道的大小         失敗：-1，設置errno

    （5）管道優劣

    優點：簡單，相比信號，套接字實現進程間通信，簡單很多。

    缺點：1. 只能單向通信，雙向通信需建立兩個管道。

               2. 只能用於父子、兄弟進程(有共同祖先)間通信。該問題后來使用fifo有名管道解決。

2. FIFO

    FIFO常被稱為有名管道，以區分管道(pipe)。管道(pipe)只能用於“有血緣關系”的進程間。但通過FIFO，不相關的進程也能交換數據。

    FIFO是Linux基礎文件類型中的一種。但FIFO文件在磁盤上沒有數據塊，僅僅用來標識內核中一條通道。各進程可以打開這個文件進行read/write，實際上是在讀寫內核通道，這樣就實現了進程間通信。

創建方式：

    1. 命令：mkfifo 管道名

    2. 庫函數：int mkfifo(const char *pathname,  mode_t mode);  成功：0； 失敗：-1

         一旦使用mkfifo創建了一個FIFO，就可以使用open打開它，常見的文件I/O函數都可用於fifo。如：close、read、write、unlink等。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

int main(int argc,char * argv[])
{
    if(argc != 2){
        printf("./a.out fifoname\n");
        return -1;
    }

    int ret = mkfifo(argv[1], 0666);
    if (ret < 0 && errno != EEXIST)
    {
        printf("create fifo file %s failed\n", argv[1]);
        return -1;
    }

    // 創建一個 myfifo 文件
    //打開fifo文件
    printf("begin open ....\n");
    int fd = open(argv[1],O_WRONLY);
    printf("end open ....\n");
    //寫
    char buf[256];
    int num = 1;
    while(1){
        memset(buf,0x00,sizeof(buf));
        sprintf(buf,"from write data:%04d",num++);
        write(fd,buf,strlen(buf));
        sleep(1);
        //循環寫
    }
    //關閉描述符
    close(fd);
    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

int main(int argc,char *argv[])
{
    if(argc != 2){
        printf("./a.out fifoname\n");
        return -1;
    }
    printf("begin oepn read...\n");
    int fd = open(argv[1],O_RDONLY);
    printf("end oepn read...\n");

    char buf[256];
    int ret;
    while(1){
        //循環讀
        memset(buf,0x00,sizeof(buf));
        ret = read(fd,buf,sizeof(buf));
        if(ret > 0){
            printf("read:%s\n",buf);
        }
    }

    close(fd);
    return 0;
}

注意：

FIFOs
        Opening the read or write end of a FIFO blocks until the other end is also opened (by another process or thread). See fifo(7) for further details.

open注意事項，打開fifo文件的時候，read端會阻塞等待write端open，write端同理，也會阻塞等待另外一端打開。

3. 共享存儲映射

 （1）文件進程間通信

    使用文件也可以完成IPC，理論依據是，fork后，父子進程共享文件描述符。也就共享打開的文件。

 （2）存儲映射IO

    存儲映射I/O (Memory-mapped I/O) 使一個磁盤文件與存儲空間中的一個緩沖區相映射。於是當從緩沖區中取數據，就相當於讀文件中的相應字節。於此類似，將數據存入緩沖區，則相應的字節就自動寫入文件。這樣，就可在不適用read和write函數的情況下，使用地址（指針）完成I/O操作。

    使用這種方法，首先應通知內核，將一個指定文件映射到存儲區域中。這個映射工作可以通過mmap函數來實現。

    1）mmap函數

void *mmap(void *adrr, size_t length, int prot, int flags, int fd, off_t offset);

    返回：

          成功：返回創建的映射區首地址；

          失敗：MAP_FAILED宏

    參數：    

         addr：建立映射區的首地址，由Linux內核指定。使用時，直接傳遞NULL

         length：欲創建映射區的大小

         prot： 映射區權限PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE

         flags：標志位參數(常用於設定更新物理區域、設置共享、創建匿名映射區)

                     MAP_SHARED:  會將映射區所做的操作反映到物理設備（磁盤）上。

                     MAP_PRIVATE: 映射區所做的修改不會反映到物理設備。

         fd：用來建立映射區的文件描述符

         offset：映射文件的偏移(4k的整數倍)

     2）munmap函數

    同malloc函數申請內存空間類似的，mmap建立的映射區在使用結束后也應調用類似free的函數來釋放。

int munmap(void *addr, size_t length);  成功：0； 失敗：-1

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>

int main()
{
    int fd = open("mem.txt",O_RDWR);//創建並且截斷文件
    //int fd = open("mem.txt",O_RDWR|O_CREAT|O_TRUNC,0664);//創建並且截斷文件

    ftruncate(fd,8);   
    //創建映射區
   char *mem = mmap(NULL,20,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    //char *mem = mmap(NULL,8,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);

    if(mem == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
    close(fd);
    //拷貝數據
    strcpy(mem,"helloworld");
//    mem++;
    //釋放mmap
    printf("mem = %s\n", mem);
    
    if(munmap(mem,20) < 0){
        perror("munmap err");
    }
    return 0;
}

執行結果：

執行mmap_size之前，mem.txt大小為30，代碼中 ftruncate(fd,8); 將文件截斷為8個字節大小，共享映射為20個字節，雖然文件大小（8） < 映射區大小（20），映射區可以存儲helloworld（10），同時修改文件mem.txt內容。

[root@centos 09-linux-day06]# cat mem.txt
*****************************
[root@centos 09-linux-day06]# ./mmap_size
mem = helloworld
[root@centos 09-linux-day06]# cat mem.txt
hellowor

 

    借鑒malloc和free函數原型，嘗試裝自定義函數smalloc，sfree來完成映射區的建立和釋放。思考函數接口該如何設計？

    mmap九問：
   1. 如果更改mem變量的地址，釋放的時候munmap，傳入mem還能成功嗎？ 不能！！

   2. 如果對mem越界操作會怎么樣？ 文件的大小對映射區操作有影響，盡量避免。

   3. 如果文件偏移量隨便填個數會怎么樣？ offset必須是 4k的整數倍

   4 如果文件描述符先關閉，對mmap映射有沒有影響？沒有影響

   5. open的時候，可以新創建一個文件來創建映射區嗎？不可以用大小為0的文件

   6. open文件選擇O_WRONLY，可以嗎？ 不可以： Permission denied

   7. 當選擇MAP_SHARED的時候，open文件選擇O_RDONLY，prot可以選擇PROT_READ|PROT_WRITE嗎？Permission denied ，SHARED的時候，映射區的權限 <= open文件的權限

   8. mmap什么情況下會報錯？很多情況

   9. 如果不判斷返回值會怎么樣？ 會死的很難堪！！

總結：使用mmap時務必注意以下事項：

   1. 創建映射區的過程中，隱含着一次對映射文件的讀操作。

   2. 當MAP_SHARED時，要求：映射區的權限應 <=文件打開的權限(出於對映射區的保護)。而MAP_PRIVATE則無所謂，因為mmap中的權限是對內存的限制。

   3. 映射區的釋放與文件關閉無關。只要映射建立成功，文件可以立即關閉。

   4. 特別注意，當映射文件大小為0時，不能創建映射區。所以：用於映射的文件必須要有實際大小！！    mmap使用時常常會出現總線錯誤，通常是由於共享文件存儲空間大小引起的。

   5. munmap傳入的地址一定是mmap的返回地址。堅決杜絕指針++操作。

   6. 文件偏移量必須為4K的整數倍

   7. mmap創建映射區出錯概率非常高，一定要檢查返回值，確保映射區建立成功再進行后續操作。

 （3）mmap父子進程間通信

   父子等有血緣關系的進程之間也可以通過mmap建立的映射區來完成數據通信。但相應的要在創建映射區的時候指定對應的標志位參數flags：

   MAP_PRIVATE:  (私有映射)  父子進程各自獨占映射區；

   MAP_SHARED:  (共享映射)  父子進程共享映射區；

   練習：父進程創建映射區，然后fork子進程，子進程修改映射區內容，而后，父進程讀取映射區內容，查驗是否共享。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h>

int main()
{
    // 先創建映射區
    int fd = open("mem.txt",O_RDWR);
    int *mem = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    //int *mem = mmap(NULL,4, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
    if(mem == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
    // fork子進程
    pid_t pid = fork();

    // 父進程和子進程交替修改數據
    if(pid == 0 ){
        //son 
        *mem = 100;
        printf("child,*mem = %d\n",*mem);
        sleep(3);
        printf("child,*mem = %d\n",*mem);
    }
    else if(pid > 0){
        //parent
        sleep(1);
        printf("parent,*mem=%d\n",*mem);
        *mem = 1001;
        printf("parent,*mem=%d\n",*mem);
        wait(NULL);
    }

    munmap(mem,4);
    close(fd);
    
    return 0;
}

   結論：父子進程共享：1. 打開的文件  2. mmap建立的映射區(但必須要使用MAP_SHARED)

 （4）匿名映射

   通過使用我們發現，使用映射區來完成文件讀寫操作十分方便，父子進程間通信也較容易。但缺陷是，每次創建映射區一定要依賴一個文件才能實現。通常為了建立映射區要open一個temp文件，創建好了再unlink、close掉，比較麻煩。 可以直接使用匿名映射來代替。其實Linux系統給我們提供了創建匿名映射區的方法，無需依賴一個文件即可創建映射區。同樣需要借助標志位參數flags來指定。

   使用MAP_ANONYMOUS (或MAP_ANON)， 如:

int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0); 

   需注意的是，MAP_ANONYMOUS和MAP_ANON這兩個宏是Linux操作系統特有的宏。在類Unix系統中如無該宏定義，可使用如下兩步來完成匿名映射區的建立。

         1）fd = open("/dev/zero", O_RDWR);

         2）p = mmap(NULL, size, PROT_READ|PROT_WRITE, MMAP_SHARED, fd, 0);

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h>

int main()
{
    int *mem = mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANON,-1,0);

    if(mem == MAP_FAILED){
        perror("mmap err");
        return -1;
    }

    pid_t pid = fork();

    if(pid == 0 ){
        //son 
        *mem = 100;
        printf("child,*mem=%d\n",*mem);
        sleep(3);
        printf("child,*mem=%d\n",*mem);
    }else if(pid > 0){
        //parent 
        sleep(1);
        printf("parent,*mem=%d\n",*mem);
        *mem = 200;
        printf("parent,*mem=%d\n",*mem);
        wait(NULL);
    }

    munmap(mem,4);
    
    return 0;
}

（5）mmap無血緣關系進程間通信

   實質上mmap是內核借助文件幫我們創建了一個映射區，多個進程之間利用該映射區完成數據傳遞。由於內核空間多進程共享，因此無血緣關系的進程間也可以使用mmap來完成通信。只要設置相應的標志位參數flags即可。若想實現共享，當然應該使用MAP_SHARED了。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h>

typedef struct  _Student{
    int sid;
    char sname[20];
}Student;

int main(int argc,char *argv[])
{
    if(argc != 2){
        printf("./a.out filename\n");
        return -1;
    }
    
    // 1. open file 
    int fd = open(argv[1],O_RDWR|O_CREAT|O_TRUNC,0666);
    int length = sizeof(Student);

    ftruncate(fd,length);

    // 2. mmap
    Student * stu = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    
    if(stu == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
    int num = 1;
    // 3. 修改內存數據
    while(1){
        stu->sid = num;
        sprintf(stu->sname,"from mmap write-%03d",num++);
        sleep(1);//相當於沒隔1s修改一次映射區的內容
    }
    // 4. 釋放映射區和關閉文件描述符
    munmap(stu,length);
    close(fd);

    return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/wait.h>

typedef struct _Student{
    int sid;
    char sname[20];
}Student;

int main(int argc,char *argv[])
{
    //open file 
    int fd = open(argv[1],O_RDWR);
    //mmap 
    int length = sizeof(Student);
    Student *stu = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if(stu == MAP_FAILED){
        perror("mmap err");
        return -1;
    }
    //read data 
    while(1){
        printf("sid=%d,sname=%s\n",stu->sid,stu->sname);
        sleep(1);
    }
    //close and munmap 
    munmap(stu,length);
    close(fd);
    return 0;
}

練習：

    1.通過命名管道傳輸數據，進程A和進程B，進程A將一個文件（MP3）發送給進程B？
    2.實現多進程拷貝文件？

實現思路：

代碼實現：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

int main(int argc, char *argv[])
{
    //拷貝文件起的進程數，通過參數輸入，默認是5個
    int n = 5;
    //輸入參數至少是3，第4個參數是進程個數
    if (argc < 3)
    {
        printf("./a.out src dst [n]\n");
        return -1;
    }
    if (argc == 4)
    {
        n = atoi(argv[3]);
    }

    //打開源文件
    int srcfd = open(argv[1], O_RDONLY);
    if (srcfd < 0)
    {
        perror("open src err:");
        exit(1);
    }

    //打開目標文件
    int dstfd = open(argv[2], O_RDWR|O_CREAT|O_TRUNC, 0644);
    if (dstfd < 0)
    {
        perror("open dst err:");
        exit(1);
    }

    //目標拓展，從源文件獲得文件大小，stat
    struct stat sb;
    stat(argv[1], &sb);
    //將目標文件設置為和源文件大小相同
    int len = sb.st_size;
    truncate(argv[2], len);

    //將源文件映射到緩沖區
    char *psrc = mmap(NULL, len, PROT_READ, MAP_SHARED, srcfd, 0);
    if (psrc == MAP_FAILED)
    {
        perror("mmap src err:");
        exit(1);
    }

    //將目標文件映射
    char *pdst = mmap(NULL, len, PROT_READ|PROT_WRITE, MAP_SHARED, dstfd, 0);
    if (pdst == MAP_FAILED)
    {
        perror("mmap pdst err:");
        exit(1);
    }
    //創建多個子進程
    int i = 0;
    for (i = 0; i < n; i++)
    {
        if (fork() == 0)
        {
            break;
        }
    }
    //計算子進程需要拷貝的起點大小
    int cpsize = len/n;
    int mod = len%n;
    //數據拷貝，memcpy
    if (i < n)
    {
        //最后一個子進程
        if (i == n-1)
        {
            memcpy(pdst+i*cpsize, psrc+i*cpsize, cpsize+mod);
        }
        else 
        {
            memcpy(pdst+i*cpsize, psrc+i*cpsize, cpsize);
        }
    }
    else
    {
        for (i = 0; i < n; i++)
        {
            //回收子線程
            wait(NULL);
        }
    }
    //釋放映射區
    if (munmap(psrc, len) < 0)
    {
        perror("munmap src err:");
        exit(1);
    }

    if (munmap(pdst, len) < 0)
    {
        perror("munmap dst err:");
        exit(1);
    }

    //關閉文件
    close(srcfd);
    close(dstfd);
    
    return 0;
}