Linux 進程間通信（IPC）詳解

進程間通信（IPC）深入解析

一、進程間通信概述

在操作系統里，不同進程間常常需要進行數據交換、同步協調等操作，進程間通信（Inter - Process Communication，IPC）機制應運而生。在Linux系統中，常見的IPC機制有管道、信號量、共享內存、消息隊列和套接字。這些機制各自具備獨特的特性，適用于不同的應用場景，并且在各類系統和應用程序開發中得到廣泛應用，也是技術面試中的重點考查內容。

思考問題1：為什么需要進程間通信？

在多進程的環境下，各個進程通常是獨立運行的，但有些情況下，它們需要協同工作。比如，一個進程負責收集用戶輸入，另一個進程負責對這些輸入進行處理，這就需要兩個進程之間進行數據傳遞。另外，當多個進程需要訪問同一資源時，為了避免沖突，就需要通過進程間通信來進行同步和協調。

思考問題2：不同的IPC機制適用于哪些場景？

不同的IPC機制有不同的特點和適用場景。例如，管道適合簡單的父子進程間的數據傳遞；信號量主要用于進程間的同步和互斥；共享內存適合大量數據的快速傳輸；消息隊列適用于需要按消息類型分類處理數據的場景；套接字則常用于網絡環境下的進程間通信。

二、管道

2.1 管道分類

管道分為有名（命名）管道和無名管道。

有名管道

有名管道也叫命名管道，它以文件的形式存在于文件系統中，不同進程可以通過這個文件進行通信，即便這些進程沒有親緣關系。

mkfifo fifo		# 創建一個叫做fifo的管道

創建完成后，使用ls -l命令查看文件類型，會看到文件類型為p，這代表該文件是一個管道文件。

無名管道

無名管道是通過系統調用pipe創建的，它沒有對應的文件系統實體，只能用于具有親緣關系的進程（如父子進程）之間的通信。

2.2 管道的特點和阻塞行為

數據存儲

管道大小在文件系統層面顯示為零，但數據實際上是存儲在內存中的。管道本質上是內核中的一塊緩沖區，用于臨時存儲要傳輸的數據。

打開條件

讀打開和寫打開的進程必須同時打開管道。若只有讀進程打開管道，讀操作會阻塞，直到有寫進程打開并寫入數據；若只有寫進程打開管道，寫操作也會阻塞，直到有讀進程打開管道讀取數據。

讀阻塞

讀打開的進程在管道沒有數據時會阻塞，直到有數據被寫入管道。當所有寫端關閉且管道中的數據都被讀完后，讀操作會返回0，表示已到達文件末尾。

寫關閉處理

寫打開的進程關閉管道時，讀打開的進程會返回零。此時讀進程知道寫進程已經停止寫入數據，可以結束讀取操作。

2.3 如何使用管道在兩個進程之間傳遞數據？

第一步，創建一個管道文件

使用mkfifo命令創建一個命名管道文件，例如：

mkfifo fifo

第二步，創建兩個進程，`a.c`和`b.c`

//a.c用來往管道里面寫數據：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>int main()
{int fd = open("./fifo", O_WRONLY);if (fd == -1){perror("open");exit(1);}printf("fd=%d\n", fd);while (1){printf("input:\n");char buff[128] = {0};fgets(buff, 128, stdin);if (strncmp(buff, "end", 3) == 0){break;}write(fd, buff, strlen(buff));}close(fd);exit(0);
}

//b.c用來在管道里面收數據：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>int main()
{int fd = open("./fifo", O_RDONLY);if (fd == -1){perror("open");exit(1);}printf("fd=%d\n", fd);while (1){char buff[128] = {0};int n = read(fd, buff, 127);if (n == 0){break;}printf("buff = %s\n", buff);}close(fd);exit(0);
}

第三步，同時打開兩個文件，進行通信

當使用管道進行數據傳輸時，必須有兩個進程同時打開這個管道文件，一個負責讀，一個負責寫，否則不能正常打開。在打開文件后，當寫進程沒有進行寫操作前，讀進程將會阻塞。

管道的特點是讀打開和寫打開的進程可以循環讀寫數據。當管道文件被關閉后，讀操作返回值為0，可以作為讀進程結束的條件。

2.4 無名管道

無名管道通過pipe來創建。其實現原理是需要提供一個整型數組，數組的兩個元素分別作為讀端和寫端的文件描述符。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>int main()
{int fd[2];if (pipe(fd) == -1){perror("pipe");exit(1);}// 父進程寫，子進程讀pid_t pid = fork();if (pid == -1){perror("fork");exit(1);}if (pid == 0){close(fd[1]);while (1){char buff[128] = {0};if (read(fd[0], buff, 127) == 0){break;}printf("child read:%s\n", buff);}close(fd[0]);}else{close(fd[0]);while (1){printf("input:\n");char buff[128] = {0};fgets(buff, 128, stdin);if (strncmp(buff, "end", 3) == 0){break;}write(fd[1], buff, strlen(buff));}close(fd[1]);}exit(0);
}

2.5 有名管道和無名管道的區別

通信范圍：無名管道只能在父子進程之間通信，而有名管道可以在任意兩個進程之間通信。
存在形式：無名管道沒有對應的文件系統實體，而有名管道以文件的形式存在于文件系統中。

2.6 管道的通信方式

管道的通信方式是半雙工，即能發送和接收數據，但不能同時進行發送和接收操作。

2.7 寫入管道的數據位置

寫入管道的數據存儲在內存中。不使用文件進行數據傳遞是因為使用文件進行傳遞涉及到I/O操作，效率較低，而管道直接在內存中操作，數據傳輸速度更快。

2.8 管道的實現原理

假設管道有一個分配的內存空間，將其劃分為一個字節一個字節的單元，有兩個操作這塊空間的指針。用size來表示管道的總大小，設一個頭指針和一個尾指針指向管道的起始位置。寫入數據時，頭指針往后移動，指向待寫入的下一個位置；讀數據時，讀掉尾指針所在位置的數據，然后尾指針往后移動。只要尾指針趕上頭指針，說明管道中的數據已讀完。等到頭指針指到內存最末尾時，會循環到起始地址。管道的內存是有限的，在沒讀掉的位置不能寫入數據，就像一個循環隊列一樣。

思考問題3：管道的緩沖區大小有限制嗎？如果數據量超過緩沖區大小會怎樣？

管道的緩沖區大小是有限制的，不同的系統可能有不同的默認值，通常為幾KB到幾十KB不等。當數據量超過緩沖區大小時，寫操作會阻塞，直到有足夠的空間可以繼續寫入數據。這是為了防止數據溢出，保證數據的有序傳輸。

思考問題4：管道在多進程環境下可能會出現哪些問題？如何解決？

在多進程環境下，管道可能會出現數據競爭、死鎖等問題。例如，多個寫進程同時向管道寫入數據可能會導致數據混亂；如果讀進程和寫進程的操作不協調，可能會出現死鎖。解決這些問題可以使用同步機制，如信號量、互斥鎖等，來協調進程對管道的訪問。

2.9 寫端關閉和讀端關閉的處理

當寫端關閉時，讀端read()會返回0；當讀關閉時，寫端write()會異常終止（觸發SIGPIPE信號）。

三、信號量

3.1 PV操作

信號量通常是一個正數值，一般代表可用資源的數目。對信號量的操作主要有PV操作。

P操作：獲取資源，對信號量的值減一。如果減一后信號量的值小于0，進程會進入阻塞狀態，等待其他進程釋放資源。
V操作：釋放資源，對信號量的值加一。如果加一后信號量的值小于等于0，說明有進程在等待該資源，會喚醒一個等待的進程。

3.2 相關概念

臨界資源：一次僅允許一個進程使用的共享資源，如打印機、共享內存區域等。
臨界區：訪問臨界資源的代碼段。為了保證臨界資源的正確使用，需要對臨界區進行保護，防止多個進程同時訪問。

3.3 信號量的操作步驟

創建初始化：使用semget函數創建信號量集，并使用semctl函數進行初始化。
P操作，獲取資源：使用semop函數執行P操作，獲取對臨界資源的訪問權限。
V操作，釋放資源：使用semop函數執行V操作，釋放對臨界資源的訪問權限。PV操作沒有嚴格的先后順序，要根據當時的使用需求來決定。
刪除信號量：使用semctl函數刪除信號量集。

3.4 信號量的操作和接口

信號量的主要操作函數有semget（創建）、semctl（控制，初始化）和semop（PV操作）。

//sem.h
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/sem.h>union semun 
{int val;    
};void sem_init();
void sem_p();
void sem_v();
void sem_destroy();

//sem.c
#include "sem.h"
static int semid = -1;void sem_init()
{semid = semget((key_t)1234, 1, IPC_CREAT | IPC_EXCL | 0600);if (semid == -1){semid = semget((key_t)1234, 1, IPC_CREAT | 0600);if (semid == -1){perror("semget");return;}}else{union semun a;a.val = 1;if (semctl(semid, 0, SETVAL, a) == -1) // SETVAL表示初始化值{perror("semctl setval");}}
}void sem_p()
{struct sembuf buf;buf.sem_num = 0; // 信號量的下標buf.sem_op = -1;buf.sem_flg = SEM_UNDO; // 這個標志位表示著當操作發生異常時由內核釋放資源，避免資源一直占用if (semop(semid, &buf, 1) == -1){perror("semop p");}
}void sem_v()
{struct sembuf buf;buf.sem_num = 0;buf.sem_op = 1;buf.sem_flg = SEM_UNDO; // 這個標志位表示著當操作發生異常時由內核釋放資源，避免資源一直占用if (semop(semid, &buf, 1) == -1){perror("semop v");}
}void sem_destroy()
{if (semctl(semid, 0, IPC_RMID) == -1) // IPC_RMID表示刪除{perror("semctl destroy");}    
}

3.5 創建兩個進程使用信號量進行資源調用

//a.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "sem.h"int main()
{sem_init();for (int i = 0; i < 5; i++){sem_p();printf("A");fflush(stdout);int n = rand() % 3;sleep(n);printf("A");fflush(stdout);n = rand() % 3;sleep(n);sem_v();}return 0;
}

//b.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "sem.h"int main()
{sem_init();for (int i = 0; i < 5; i++){sem_p();printf("B");fflush(stdout);int n = rand() % 3;sleep(n);printf("B");fflush(stdout);n = rand() % 3;sleep(n);sem_v();}sleep(10);sem_destroy();return 0;
}

思考問題5：信號量的值可以為負數嗎？負數代表什么含義？

信號量的值可以為負數。當信號量的值為負數時，其絕對值表示正在等待該資源的進程數量。例如，信號量的值為 -2，表示有兩個進程正在等待該資源的釋放。

思考問題6：如果在使用信號量時忘記釋放資源（即沒有執行V操作）會怎樣？

如果忘記執行V操作，信號量的值不會增加，其他等待該資源的進程將一直處于阻塞狀態，無法獲取資源，從而導致死鎖或資源饑餓問題。因此，在使用信號量時，必須確保在適當的時候執行V操作，釋放資源。

四、共享內存

4.1 共享內存的原理和優勢

共享內存是一種高效的進程間通信方式，它允許不同進程直接訪問同一塊物理內存區域，避免了數據的多次拷貝，從而提高了數據傳輸的效率。
在這里插入圖片描述

//a.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/shm.h>int main()
{// 創建共享內存int shmid = shmget((key_t)1234, 128, IPC_CREAT | 0600);if (shmid == -1){perror("shmget");exit(1);}// 獲取共享內存char* s = (char*)shmat(shmid, NULL, 0);if (s == (char*)-1){perror("shmat");exit(1);}while (1){char buff[128] = {0};fgets(buff, 128, stdin);strcpy(s, buff);if (strncmp(buff, "end", 3) == 0){break;}}// 分離共享內存shmdt(s);exit(0);
}

//b.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/shm.h>int main()
{// 創建共享內存int shmid = shmget((key_t)1234, 128, IPC_CREAT | 0600);if (shmid == -1){perror("shmget");exit(1);}// 獲取共享內存char* s = (char*)shmat(shmid, NULL, 0);if (s == (char*)-1){perror("shmat");exit(1);}while (1){if (strncmp(s, "end", 3) == 0){break;}printf("s=%s", s);sleep(1);}// 分離共享內存shmdt(s);// 銷毀共享內存shmctl(shmid, IPC_RMID, NULL);exit(0);
}

4.2 存在問題及改進方案

上述代碼存在問題：當沒有輸入值的時候，b.c會循環打印當時的共享內存中的值。改進方案是使用信號量，讓兩個程序不能同時訪問臨界資源。

4.3 共享內存和信號量的使用

需要使用信號量的兩個文件sem.c和sem.h，跟之前不同的是之前使用了一個信號量，這次需要使用兩個。

//sem.h
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/sem.h>union semun 
{int val;    
};void sem_init();
void sem_p(int index);
void sem_v(int index);
void sem_destroy();

//sem.c
#include "sem.h"
static int semid = -1;void sem_init()
{semid = semget((key_t)1234, 2, IPC_CREAT | IPC_EXCL | 0600);if (semid == -1){semid = semget((key_t)1234, 2, IPC_CREAT | 0600);if (semid == -1){perror("semget");return;}}else{union semun a;int arr[2] = {1, 0};for (int i = 0; i < 2; i++){a.val = arr[i];if (semctl(semid, i, SETVAL, a) == -1) // SETVAL表示初始化值{perror("semctl setval");}            }        }
}void sem_p(int index)
{struct sembuf buf;buf.sem_num = index; // 信號量的下標buf.sem_op = -1;buf.sem_flg = SEM_UNDO; // 這個標志位表示著當操作發生異常時由內核釋放資源，避免資源一直占用if (semop(semid, &buf, 1) == -1){perror("semop p");}
}void sem_v(int index)
{struct sembuf buf;buf.sem_num = index;buf.sem_op = 1;buf.sem_flg = SEM_UNDO; // 這個標志位表示著當操作發生異常時由內核釋放資源，避免資源一直占用if (semop(semid, &buf, 1) == -1){perror("semop v");}
}void sem_destroy()
{if (semctl(semid, 0, IPC_RMID) == -1) // IPC_RMID表示刪除{perror("semctl destroy");}    
}

//a.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/shm.h>
#include "sem.h"int main()
{// 創建共享內存int shmid = shmget((key_t)1234, 128, IPC_CREAT | 0600);if (shmid == -1){perror("shmget");exit(1);}// 映射共享內存char* s = (char*)shmat(shmid, NULL, 0);if (s == (char*)-1){perror("shmat");exit(1);}sem_init();while (1){printf("input:\n");char buff[128] = {0};fgets(buff, 128, stdin);sem_p(0); // s1,第一個信號量，初始值為1strcpy(s, buff);sem_v(1); // s2,第二個信號量，初始值為0if (strncmp(buff, "end", 3) == 0){break;}}// 分離共享內存shmdt(s);exit(0);
}

//b.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/shm.h>
#include "sem.h"int main()
{// 創建共享內存int shmid = shmget((key_t)1234, 128, IPC_CREAT | 0600);if (shmid == -1){perror("shmget");exit(1);}// 獲取共享內存char* s = (char*)shmat(shmid, NULL, 0);if (s == (char*)-1){perror("shmat");exit(1);}sem_init();while (1){sem_p(1);if (strncmp(s, "end", 3) == 0){break;}printf("s=%s", s);sem_v(0);}sem_destroy();// 斷開共享內存映射shmdt(s);// 銷毀shmctl(shmid, IPC_RMID, NULL);exit(0);
}

4.4 共享內存和管道的區別

共享內存對物理內存進行操作，管道對內核緩沖區進行操作，二者存在以下不同：

內存位置與管理方式

共享內存：共享內存是在物理內存中開辟一塊特定的區域，通過操作系統的內存管理機制，將其映射到不同進程的虛擬地址空間中。這樣，多個進程可以直接訪問同一塊物理內存，實現數據共享。操作系統負責管理共享內存的分配與回收，進程通過系統調用如shmget、shmat等來請求和使用共享內存。例如，在多個進程需要頻繁共享大量數據，如數據庫系統中多個查詢進程可能需要共享數據緩存時，就可以使用共享內存。
管道：管道的內核緩沖區是由操作系統在內核空間中分配的一塊內存區域，用于暫存管道兩端進程間傳輸的數據。它的大小通常有一定限制，并且由操作系統自動管理其數據的進出和空間利用。當進程向管道寫入數據時，數據被復制到內核緩沖區；讀進程從管道讀取數據時，再從內核緩沖區復制到用戶空間。例如，在ls | grep這樣的命令組合中，ls命令的輸出通過管道傳輸到grep命令，中間的數據就是暫存在管道的內核緩沖區中。

數據訪問特性

共享內存：進程可以直接對共享內存進行讀寫操作，就像訪問自己的內存一樣，速度非常快，因為不需要進行數據在用戶空間和內核空間之間的復制。但是，由于多個進程可以同時訪問共享內存，為了保證數據的一致性和完整性，需要使用同步機制，如信號量、互斥鎖等，來協調進程對共享內存的訪問。否則，可能會出現數據競爭等問題。
管道：管道的讀寫是有方向的，數據只能從寫端流向讀端。寫進程將數據寫入內核緩沖區，讀進程從內核緩沖區讀取數據。當管道滿時，寫進程會被阻塞，直到有數據被讀走，騰出空間；當管道空時，讀進程會被阻塞，直到有數據寫入。這種機制保證了數據的有序傳輸，但也意味著數據的讀寫是順序進行的，不能像共享內存那樣隨機訪問。

數據可見性與持續性

共享內存：一旦數據被寫入共享內存，只要其他進程有訪問權限，就可以立即看到更新后的數據，數據在共享內存中的存在是持續性的，直到被顯式修改或刪除。即使所有使用共享內存的進程都暫時退出，共享內存中的數據仍然存在于物理內存中，只要沒有被操作系統回收或其他進程修改，下次進程再訪問時，數據依然保持原來的狀態。
管道：管道中的數據具有臨時性和一次性的特點。當數據被讀進程從內核緩沖區讀取后，數據就從管道中消失了，其他進程無法再次讀取到相同的數據。而且，當所有與管道相關的文件描述符都被關閉后，管道所占用的內核緩沖區資源會被操作系統自動釋放，其中的數據也會被清除。

思考問題7：共享內存可能會帶來哪些安全隱患？如何防范？

共享內存可能帶來的安全隱患包括數據泄露、數據被惡意篡改等。由于多個進程可以直接訪問共享內存，若沒有適當的權限控制和加密機制，敏感數據可能會被其他進程獲取或修改。防范措施包括設置合理的訪問權限，對共享內存中的數據進行加密處理，以及使用同步機制確保數據的一致性和完整性。

思考問題8：如果多個進程同時對共享內存進行寫操作會怎樣？

如果多個進程同時對共享內存進行寫操作，會導致數據競爭問題，可能會使共享內存中的數據變得混亂，出現數據不一致的情況。為了避免這種情況，需要使用同步機制，如信號量、互斥鎖等，來保證同一時間只有一個進程可以對共享內存進行寫操作。

五、消息隊列

5.1 消息隊列的特點

添加消息和讀取消息是消息隊列的基本操作。消息是一個結構體，結構體名字由自己定義，特殊的地方是第一個成員是長整型（代表消息的類型），且該類型的值至少為1。

為什么消息類型必須大于零？

長整型如果是0號，就是不區分消息類型，在函數調用中，要是傳入0的話，無論是什么消息類型都能讀到。這樣可以根據不同的消息類型對消息進行分類處理，提高消息處理的靈活性和效率。

5.2 消息隊列的接口函數

msgget()：創建或獲取消息隊列。

int msgget(key_t key, int msgflg);

key是消息隊列的鍵值，用于唯一標識一個消息隊列；msgflg是標志位，用于指定創建方式和權限等。

msgrcv()：讀取消息。

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

msqid是消息隊列的標識符；msgp是用于存儲接收到的消息的緩沖區；msgsz是緩沖區的大小；msgtyp是期望接收的消息類型；msgflg是標志位，用于指定操作方式。

msgsnd()：發送消息。

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

參數含義與msgrcv類似。

5.3 示例

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/msg.h>struct mess
{long type;char buff[128];
};int main()
{int msgid = msgget((key_t)1234, IPC_CREAT | 0600);if (msgid == -1){perror("msgget");exit(1);}struct mess m;m.type = 1;strcpy(m.buff, "hello");if (msgsnd(msgid, &m, sizeof(m.buff), 0) == -1){perror("msgsnd");exit(1);}exit(0);
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/msg.h>struct mess
{long type;char buff[128];
};int main()
{int msgid = msgget((key_t)1234, IPC_CREAT | 0600);if (msgid == -1){perror("msgget");exit(1);}struct mess m;if (msgrcv(msgid, &m, sizeof(m.buff), 1, 0) == -1){perror("msgrcv");exit(1);}printf("read:%s\n", m.buff);exit(0);
}