进程间通信

进程间通信（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）

特点：消息队列是一种独立于发送和接收进程的存储机制。进程可以向消息队列发送消息，也可以从消息队列接收消息。消息队列可以实现异步通信，发送进程不需要等待接收进程的响应。
示例用法：

   #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 方式之一，因为它允许不同的进程直接访问同一块物理内存区域。这避免了数据在进程之间的复制，提高了通信效率。但是，由于存在多个进程同时访问同一块内存的情况，需要考虑同步机制。而且共享内存在不同操作系统中的实现可能不同，所以使用共享内存的程序在不同平台的可移植性比较差。
示例用法：

   #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）

特点：套接字不仅可以用于同一台机器上不同进程之间的通信，还可以用于不同机器上的进程之间的通信。它支持多种通信协议，如 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）

性能特点：

无名管道通常比较快速，适用于父子进程之间的简单通信。由于数据在内存中传递，速度相对较快。

命名管道在性能上稍逊于无名管道，因为它涉及到文件系统的操作。但是，命名管道可以在不相关的进程之间使用，提供了更大的灵活性。

适用场景：

无名管道适用于简单的父子进程通信场景，例如在命令行中使用管道将一个命令的输出作为另一个命令的输入。

命名管道适用于需要在不相关进程之间进行通信的场景，例如不同的应用程序之间的通信。

消息队列（Message Queue）

性能特点：

消息队列提供了一种异步通信方式，发送进程不需要等待接收进程的响应。这可以提高系统的并发性。

消息队列的性能取决于消息的大小和数量。较小的消息和较少的消息数量通常会导致更好的性能。

消息队列的操作相对较慢，因为它涉及到内核的干预和系统调用。

适用场景：

消息队列适用于需要异步通信的场景，例如在分布式系统中，不同的节点之间需要进行通信，但不需要立即响应。

消息队列也适用于需要发送大量小消息的场景，例如在日志系统中，不同的进程可以将日志消息发送到消息队列中，然后由一个专门的进程进行处理。

共享内存（Shared Memory）

性能特点：

共享内存是最快的进程间通信方式之一，因为它允许不同的进程直接访问同一块物理内存区域，避免了数据在进程之间的复制。

共享内存的性能取决于内存的访问模式和并发访问的程度。如果多个进程同时访问共享内存，可能会出现竞争条件，需要使用同步机制来确保数据的一致性。

共享内存的操作相对简单，不需要进行系统调用，因此可以提高系统的性能。

适用场景：

共享内存适用于需要高效数据共享的场景，例如在高性能计算中，多个进程需要共享大量的数据。

共享内存也适用于需要快速通信的场景，例如在实时系统中，不同的进程需要快速交换数据。

信号量（Semaphore）

性能特点：

信号量主要用于进程间的同步和互斥，而不是用于数据传输。因此，它的性能主要取决于同步操作的频率和复杂性。

信号量的操作相对较慢，因为它涉及到系统调用和内核的干预。

信号量的性能还受到信号量的初始值和使用方式的影响。如果信号量的初始值设置不当，可能会导致死锁或性能下降。

适用场景：

信号量适用于需要同步和互斥的场景，例如在多线程编程中，不同的线程需要访问共享资源，需要使用信号量来确保数据的一致性。

信号量也适用于需要控制对共享资源的访问的场景，例如在数据库系统中，多个进程需要访问数据库，需要使用信号量来控制并发访问的程度。

套接字（Socket）

性能特点：

套接字可以用于不同机器上的进程之间的通信，因此它的性能受到网络延迟和带宽的限制。

套接字的操作相对较慢，因为它涉及到网络通信和系统调用。

套接字的性能还受到通信协议的选择和使用方式的影响。例如，TCP 协议提供了可靠的通信，但相对较慢；UDP 协议提供了不可靠的通信，但相对较快。

适用场景：

套接字适用于需要在不同机器上的进程之间进行通信的场景，例如在分布式系统中，不同的节点之间需要进行通信。

套接字也适用于需要与外部系统进行通信的场景，例如在网络应用程序中，需要与服务器进行通信。

总体而言，共享内存通常是最快的进程间通信方式，但它需要谨慎使用同步机制来确保数据的一致性。管道和消息队列适用于简单的通信场景，而套接字适用于需要在不同机器上进行通信的场景。信号量主要用于同步和互斥，而不是用于数据传输。在选择进程间通信方式时，需要根据具体的应用场景和性能要求进行权衡。

标签：信号量,共享内存,int,通信,间通信,进程,include
From： https://www.cnblogs.com/zccblogs/p/18378860

进程间通信

进程间通信

管道（Pipe）

无名管道：

命名管道（FIFO）：

消息队列（Message Queue）

共享内存（Shared Memory）

信号量（Semaphore）

套接字（Socket）

性能对比

管道（Pipe）

消息队列（Message Queue）

共享内存（Shared Memory）

信号量（Semaphore）

套接字（Socket）

相关文章

赞助商

阅读排行