進程間通信
進程間通信
進程間通信（Inter-Process Communication，IPC）是指在不同進程之間進行數據交換和信息傳遞的機制。常見的通信方式有：管道、消息隊列、共享內存、信號量、socket。
管道（Pipe）
無名管道：
特點：只能在具有親緣關系的進程之間使用（如父子進程）。它是半雙工的，即數據只能在一個方向上流動，若要實現雙向通信，需要建立兩個管道。
示例用法：
#include <iostream>
#include <unistd.h>
int main() {
int pipefd[2];
pipe(pipefd);
if (fork() == 0) {
// 子進程
close(pipefd[1]);
char buffer[100];
read(pipefd[0], buffer, sizeof(buffer));
std::cout << "Child received: " << buffer << std::endl;
close(pipefd[0]);
} else {
// 父進程
close(pipefd[0]);
write(pipefd[1], "Hello from parent!", 19);
close(pipefd[1]);
}
return 0;
}
命名管道（FIFO）：
特點：可以在不相關的進程之間進行通信。命名管道有一個文件名，可以通過這個文件名進行訪問。它也是半雙工的，但可以通過建立兩個命名管道實現雙向通信。
示例用法：
#include <iostream>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
int main() {
const char* fifoName = "myfifo";
mkfifo(fifoName, 0666);
if (fork() == 0) {
// 子進程
int fd = open(fifoName, O_RDONLY);
char buffer[100];
read(fd, buffer, sizeof(buffer));
std::cout << "Child received: " << buffer << std::endl;
close(fd);
} else {
// 父進程
int fd = open(fifoName, O_WRONLY);
write(fd, "Hello from parent!", 19);
close(fd);
}
unlink(fifoName);
return 0;
}
消息隊列（Message Queue）
特點：消息隊列是一種獨立于發(fā)送和接收進程的存儲機制。進程可以向消息隊列發(fā)送消息，也可以從消息隊列接收消息。消息隊列可以實現異步通信，發(fā)送進程不需要等待接收進程的響應。
示例用法：
#include <iostream>
#include <sys/ipc.h>
#include <sys/msg.h>
struct message {
long mtype;
char mtext[100];
};
int main() {
key_t key = ftok("progfile", 65);
int msgid = msgget(key, 0666 | IPC_CREAT);
if (fork() == 0) {
// 子進程
struct message msg;
msgrcv(msgid, &msg, sizeof(msg.mtext), 1, 0);
std::cout << "Child received: " << msg.mtext << std::endl;
msgctl(msgid, IPC_RMID, nullptr);
} else {
// 父進程
struct message msg;
msg.mtype = 1;
strcpy(msg.mtext, "Hello from parent!");
msgsnd(msgid, &msg, sizeof(msg.mtext), 0);
}
return 0;
}
共享內存（Shared Memory）
特點：共享內存是最快的 IPC 方式之一，因為它允許不同的進程直接訪問同一塊物理內存區(qū)域。這避免了數據在進程之間的復制，提高了通信效率。但是，由于存在多個進程同時訪問同一塊內存的情況，需要考慮同步機制。而且共享內存在不同操作系統(tǒng)中的實現可能不同，所以使用共享內存的程序在不同平臺的可移植性比較差。
示例用法：
#include <iostream>
#include <sys/ipc.h>
#include <sys/shm.h>
int main() {
key_t key = ftok("shmfile", 65);
int shmid = shmget(key, 1024, 0666 | IPC_CREAT);
char* shmaddr = (char*)shmat(shmid, nullptr, 0);
if (fork() == 0) {
// 子進程
std::cout << "Child read from shared memory: " << shmaddr << std::endl;
shmdt(shmaddr);
} else {
// 父進程
strcpy(shmaddr, "Hello from parent!");
wait(nullptr);
shmdt(shmaddr);
shmctl(shmid, IPC_RMID, nullptr);
}
return 0;
}
信號量（Semaphore）
特點：信號量主要用于進程間的同步和互斥。它可以控制對共享資源的訪問，確保多個進程不會同時訪問同一資源而導致數據不一致。
示例用法：
#include <iostream>
#include <sys/ipc.h>
#include <sys/sem.h>
union semun {
int val;
struct semid_ds* buf;
unsigned short* array;
};
void semaphoreWait(int semid) {
struct sembuf sops = {0, -1, 0};
semop(semid, &sops, 1);
}
void semaphoreSignal(int semid) {
struct sembuf sops = {0, 1, 0};
semop(semid, &sops, 1);
}
int main() {
key_t key = ftok("semfile", 65);
int semid = semget(key, 1, 0666 | IPC_CREAT);
semun initVal = {1};
semctl(semid, 0, SETVAL, initVal);
if (fork() == 0) {
// 子進程
semaphoreWait(semid);
std::cout << "Child accessed shared resource." << std::endl;
semaphoreSignal(semid);
} else {
// 父進程
semaphoreWait(semid);
std::cout << "Parent accessed shared resource." << std::endl;
semaphoreSignal(semid);
}
semctl(semid, 0, IPC_RMID);
return 0;
}
套接字（Socket）
特點：套接字不僅可以用于同一臺機器上不同進程之間的通信，還可以用于不同機器上的進程之間的通信。它支持多種通信協(xié)議，如 TCP 和 UDP。
示例用法（基于 TCP 的進程間通信）：
服務器端：
#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>
int main() {
int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
if (serverSocket == -1) {
std::cerr << "Error creating server socket." << std::endl;
return -1;
}
sockaddr_in serverAddress;
serverAddress.sin_family = AF_INET;
serverAddress.sin_addr.s_addr = INADDR_ANY;
serverAddress.sin_port = htons(8888);
if (bind(serverSocket, reinterpret_cast<struct sockaddr*>(&serverAddress), sizeof(serverAddress)) == -1) {
std::cerr << "Error binding server socket." << std::endl;
close(serverSocket);
return -1;
}
if (listen(serverSocket, 5) == -1) {
std::cerr << "Error listening for connections." << std::endl;
close(serverSocket);
return -1;
}
int clientSocket = accept(serverSocket, nullptr, nullptr);
if (clientSocket == -1) {
std::cerr << "Error accepting client connection." << std::endl;
close(serverSocket);
return -1;
}
char buffer[1024];
ssize_t bytesRead = read(clientSocket, buffer, sizeof(buffer));
if (bytesRead > 0) {
std::cout << "Received from client: " << buffer << std::endl;
}
close(clientSocket);
close(serverSocket);
return 0;
}
客戶端：
#include <iostream>
#include <cstring>
#include <unistd.h>
#include <arpa/inet.h>
int main() {
int clientSocket = socket(AF_INET, SOCK_STREAM, 0);
if (clientSocket == -1) {
std::cerr << "Error creating client socket." << std::endl;
return -1;
}
sockaddr_in serverAddress;
serverAddress.sin_family = AF_INET;
serverAddress.sin_addr.s_addr = inet_addr("127.0.0.1");
serverAddress.sin_port = htons(8888);
if (connect(clientSocket, reinterpret_cast<struct sockaddr*>(&serverAddress), sizeof(serverAddress)) == -1) {
std::cerr << "Error connecting to server." << std::endl;
close(clientSocket);
return -1;
}
const char* message = "Hello from client!";
send(clientSocket, message, strlen(message), 0);
close(clientSocket);
return 0;
}
性能對比
管道（Pipe）
性能特點：
- 無名管道通常比較快速，適用于父子進程之間的簡單通信。由于數據在內存中傳遞，速度相對較快。
- 命名管道在性能上稍遜于無名管道，因為它涉及到文件系統(tǒng)的操作。但是，命名管道可以在不相關的進程之間使用，提供了更大的靈活性。
適用場景：
- 無名管道適用于簡單的父子進程通信場景，例如在命令行中使用管道將一個命令的輸出作為另一個命令的輸入。
- 命名管道適用于需要在不相關進程之間進行通信的場景，例如不同的應用程序之間的通信。
消息隊列（Message Queue）
性能特點：
- 消息隊列提供了一種異步通信方式，發(fā)送進程不需要等待接收進程的響應。這可以提高系統(tǒng)的并發(fā)性。
- 消息隊列的性能取決于消息的大小和數量。較小的消息和較少的消息數量通常會導致更好的性能。
- 消息隊列的操作相對較慢，因為它涉及到內核的干預和系統(tǒng)調用。
適用場景：
- 消息隊列適用于需要異步通信的場景，例如在分布式系統(tǒng)中，不同的節(jié)點之間需要進行通信，但不需要立即響應。
- 消息隊列也適用于需要發(fā)送大量小消息的場景，例如在日志系統(tǒng)中，不同的進程可以將日志消息發(fā)送到消息隊列中，然后由一個專門的進程進行處理。
共享內存（Shared Memory）
性能特點：
- 共享內存是最快的進程間通信方式之一，因為它允許不同的進程直接訪問同一塊物理內存區(qū)域，避免了數據在進程之間的復制。
- 共享內存的性能取決于內存的訪問模式和并發(fā)訪問的程度。如果多個進程同時訪問共享內存，可能會出現競爭條件，需要使用同步機制來確保數據的一致性。
- 共享內存的操作相對簡單，不需要進行系統(tǒng)調用，因此可以提高系統(tǒng)的性能。
適用場景：
- 共享內存適用于需要高效數據共享的場景，例如在高性能計算中，多個進程需要共享大量的數據。
- 共享內存也適用于需要快速通信的場景，例如在實時系統(tǒng)中，不同的進程需要快速交換數據。
信號量（Semaphore）
性能特點：
- 信號量主要用于進程間的同步和互斥，而不是用于數據傳輸。因此，它的性能主要取決于同步操作的頻率和復雜性。
- 信號量的操作相對較慢，因為它涉及到系統(tǒng)調用和內核的干預。
- 信號量的性能還受到信號量的初始值和使用方式的影響。如果信號量的初始值設置不當，可能會導致死鎖或性能下降。
適用場景：
- 信號量適用于需要同步和互斥的場景，例如在多線程編程中，不同的線程需要訪問共享資源，需要使用信號量來確保數據的一致性。
- 信號量也適用于需要控制對共享資源的訪問的場景，例如在數據庫系統(tǒng)中，多個進程需要訪問數據庫，需要使用信號量來控制并發(fā)訪問的程度。
套接字（Socket）
性能特點：
- 套接字可以用于不同機器上的進程之間的通信，因此它的性能受到網絡延遲和帶寬的限制。
- 套接字的操作相對較慢，因為它涉及到網絡通信和系統(tǒng)調用。
- 套接字的性能還受到通信協(xié)議的選擇和使用方式的影響。例如，TCP 協(xié)議提供了可靠的通信，但相對較慢；UDP 協(xié)議提供了不可靠的通信，但相對較快。
適用場景：
- 套接字適用于需要在不同機器上的進程之間進行通信的場景，例如在分布式系統(tǒng)中，不同的節(jié)點之間需要進行通信。
- 套接字也適用于需要與外部系統(tǒng)進行通信的場景，例如在網絡應用程序中，需要與服務器進行通信。
總體而言，共享內存通常是最快的進程間通信方式，但它需要謹慎使用同步機制來確保數據的一致性。管道和消息隊列適用于簡單的通信場景，而套接字適用于需要在不同機器上進行通信的場景。信號量主要用于同步和互斥，而不是用于數據傳輸。在選擇進程間通信方式時，需要根據具體的應用場景和性能要求進行權衡。
浙公網安備 33010602011771號