c++实如今同一台主机两个步伐实实际时通信

c++代码实现同一台主机两个步伐实实际时通信

对于历程间通信方式有很多种，对于本机两个步伐中可以实时通信那么应该选择哪个呢？很多人最快想到的就是socket通信。
套接字适用于跨网络的历程间通信，具有网络透明性、机动性和安全性高的优点，但性能开销较大，延迟较高！
共享内存适用于同一台呆板上的历程间通信，具有高性能、低延迟和高吞吐量的优点，但需要手动管理同步机制，安全性较低。以是我们优先使用共享内存来实现，在智能驾驶等工业场景中使用非常多。
共享内存实现

历程A：

1. #include <cstring>
2. #include <iostream>
3. #include <sys/shm.h>
4. #include <thread>
5. #include <unistd.h>
7. #define SHM_KEY_A 12345
8. #define SHM_KEY_B 67890
9. #define SHM_SIZE 1024
11. void send_messages(char* send_data)
12. {
13.     std::string message;
14.     while (std::getline(std::cin, message)) {
15.         if (message == "exit") {
16.             break;
17.         }
19.         strncpy(send_data, message.c_str(), SHM_SIZE - 1);
20.         send_data[SHM_SIZE - 1] = '\0';
22.         while (std::strlen(send_data) > 0) {
23.             usleep(100000); // 等待 100 毫秒
24.         }
25.     }
26. }
28. void receive_messages(char* recv_data)
29. {
30.     while (true) {
31.         while (std::strlen(recv_data) == 0) {
32.             usleep(100000); // 等待 100 毫秒
33.         }
35.         std::cout << "Received message: " << recv_data << std::endl;
37.         std::memset(recv_data, 0, SHM_SIZE);
38.     }
39. }
41. int main()
42. {
43.     // 创建共享内存A（用于接收消息）
44.     int shmid_a = shmget(SHM_KEY_A, SHM_SIZE, 0666);
45.     if (shmid_a == -1) {
46.         std::cerr << "Failed to get shared memory A" << std::endl;
47.         return 1;
48.     }
50.     // 创建共享内存B（用于发送消息）
51.     int shmid_b = shmget(SHM_KEY_B, SHM_SIZE, 0666);
52.     if (shmid_b == -1) {
53.         std::cerr << "Failed to get shared memory B" << std::endl;
54.         return 1;
55.     }
57.     // 将共享内存连接到当前进程
58.     char* recv_data = (char*)shmat(shmid_a, nullptr, 0);
59.     char* send_data = (char*)shmat(shmid_b, nullptr, 0);
61.     if (recv_data == (char*)-1 || send_data == (char*)-1) {
62.         std::cerr << "Failed to attach shared memory" << std::endl;
63.         return 1;
64.     }
66.     std::thread sender(send_messages, send_data);
67.     std::thread receiver(receive_messages, recv_data);
69.     sender.join();
70.     receiver.join();
72.     // 清理共享内存
73.     shmdt(recv_data);
74.     shmdt(send_data);
75.     shmctl(shmid_a, IPC_RMID, nullptr);
76.     shmctl(shmid_b, IPC_RMID, nullptr);
78.     return 0;
79. }

复制代码

历程B：

1. #include <cstring>
2. #include <iostream>
3. #include <sys/shm.h>
4. #include <thread>
5. #include <unistd.h>
7. #define SHM_KEY_A 12345
8. #define SHM_KEY_B 67890
9. #define SHM_SIZE 1024
11. void send_messages(char* send_data)
12. {
13.     std::string message;
14.     while (std::getline(std::cin, message)) {
15.         if (message == "exit") {
16.             break;
17.         }
19.         strncpy(send_data, message.c_str(), SHM_SIZE - 1);
20.         send_data[SHM_SIZE - 1] = '\0';
22.         while (std::strlen(send_data) > 0) {
23.             usleep(100000); // 等待 100 毫秒
24.         }
25.     }
26. }
28. void receive_messages(char* recv_data)
29. {
30.     while (true) {
31.         while (std::strlen(recv_data) == 0) {
32.             usleep(100000); // 等待 100 毫秒
33.         }
35.         std::cout << "Received message: " << recv_data << std::endl;
37.         std::memset(recv_data, 0, SHM_SIZE);
38.     }
39. }
41. int main()
42. {
43.     // 获取共享内存A（用于发送消息）
44.     int shmid_a = shmget(SHM_KEY_A, SHM_SIZE, IPC_CREAT | 0666);
45.     if (shmid_a == -1) {
46.         std::cerr << "Failed to create shared memory A" << std::endl;
47.         return 1;
48.     }
50.     // 获取共享内存B（用于接收消息）
51.     int shmid_b = shmget(SHM_KEY_B, SHM_SIZE, IPC_CREAT | 0666);
52.     if (shmid_b == -1) {
53.         std::cerr << "Failed to create shared memory B" << std::endl;
54.         return 1;
55.     }
57.     // 将共享内存连接到当前进程
58.     char* send_data = (char*)shmat(shmid_a, nullptr, 0);
59.     char* recv_data = (char*)shmat(shmid_b, nullptr, 0);
61.     if (send_data == (char*)-1 || recv_data == (char*)-1) {
62.         std::cerr << "Failed to attach shared memory" << std::endl;
63.         return 1;
64.     }
66.     std::thread sender(send_messages, send_data);
67.     std::thread receiver(receive_messages, recv_data);
69.     sender.join();
70.     receiver.join();
72.     // 清理共享内存
73.     shmdt(send_data);
74.     shmdt(recv_data);
75.     shmctl(shmid_a, IPC_RMID, nullptr);
76.     shmctl(shmid_b, IPC_RMID, nullptr);
78.     return 0;
79. }

复制代码

代码简洁比较容易。有些捞仔可能会问了，除了共享内存另有没有其它方式呢？有！当然有，只不过性能不如共享内存啦。
命名管道实现

历程A：

1. #include <fstream>
2. #include <iostream>
3. #include <sys/stat.h>
4. #include <thread>
5. #include <unistd.h>
7. #define PIPE_NAME_A "pipe_a"
8. #define PIPE_NAME_B "pipe_b"
10. void send_messages(const std::string& pipe_name)
11. {
12.     std::ofstream pipe(pipe_name);
14.     if (!pipe) {
15.         std::cerr << "Failed to open named pipe for writing" << std::endl;
16.         return;
17.     }
19.     std::cout << "Enter messages to send (type 'exit' to quit):" << std::endl;
21.     while (true) {
22.         std::string message;
23.         std::getline(std::cin, message);
25.         if (message == "exit") {
26.             break;
27.         }
29.         pipe << message << std::endl;
30.         pipe.flush();
31.     }
32. }
34. void receive_messages(const std::string& pipe_name)
35. {
36.     std::ifstream pipe(pipe_name);
38.     if (!pipe) {
39.         std::cerr << "Failed to open named pipe for reading" << std::endl;
40.         return;
41.     }
43.     std::cout << "Waiting for messages..." << std::endl;
45.     while (true) {
46.         std::string message;
47.         std::getline(pipe, message);
49.         // 处理程序在没有数据时不会频繁地检查管道，从而节省CPU资源，同时保持对新数据的响应
50.         if (pipe.eof()) {
51.             sleep(1);
52.             pipe.clear();
53.             pipe.seekg(0, std::ios::end);
54.         } else {
55.             std::cout << "Received message: " << message << std::endl;
56.         }
57.     }
58. }
60. int main()
61. {
62.     // 创建命名管道
63.     if (mkfifo(PIPE_NAME_A, 0666) == -1) {
64.         std::cerr << "Failed to create named pipe A" << std::endl;
65.         return 1;
66.     }
68.     if (mkfifo(PIPE_NAME_B, 0666) == -1) {
69.         std::cerr << "Failed to create named pipe B" << std::endl;
70.         return 1;
71.     }
73.     std::thread sender(send_messages, PIPE_NAME_A);
74.     std::thread receiver(receive_messages, PIPE_NAME_B);
76.     sender.join();
77.     receiver.join();
79.     return 0;
80. }

复制代码

历程B：

1. #include <fstream>
2. #include <iostream>
3. #include <sys/stat.h>
4. #include <thread>
5. #include <unistd.h>
7. #define PIPE_NAME_A "pipe_a"
8. #define PIPE_NAME_B "pipe_b"
10. void send_messages(const std::string& pipe_name)
11. {
12.     std::ofstream pipe(pipe_name);
14.     if (!pipe) {
15.         std::cerr << "Failed to open named pipe for writing" << std::endl;
16.         return;
17.     }
19.     std::cout << "Enter messages to send (type 'exit' to quit):" << std::endl;
21.     while (true) {
22.         std::string message;
23.         std::getline(std::cin, message);
25.         if (message == "exit") {
26.             break;
27.         }
29.         pipe << message << std::endl;
30.         pipe.flush();
31.     }
32. }
34. void receive_messages(const std::string& pipe_name)
35. {
36.     std::ifstream pipe(pipe_name);
38.     if (!pipe) {
39.         std::cerr << "Failed to open named pipe for reading" << std::endl;
40.         return;
41.     }
43.     std::cout << "Waiting for messages..." << std::endl;
45.     while (true) {
46.         std::string message;
47.         std::getline(pipe, message);
49.         if (pipe.eof()) {
50.             sleep(1);
51.             pipe.clear();
52.             pipe.seekg(0, std::ios::end);
53.         } else {
54.             std::cout << "Received message: " << message << std::endl;
55.         }
56.     }
57. }
59. int main()
60. {
61.     std::thread sender(send_messages, PIPE_NAME_B);
62.     std::thread receiver(receive_messages, PIPE_NAME_A);
64.     sender.join();
65.     receiver.join();
67.     return 0;
68. }

复制代码

相对于共享内存的优缺点：
优点：

• 简单易用：命名管道的实现相对简单，得当用于简单的历程间通信。
  

缺点：

• 性能开销：命名管道的性能略低于共享内存，因为数据需要通过内核缓冲区传输。共享内存是所有历程间通信（IPC）机制中最快的，因为它不需要在历程之间复制数据。
  
• 单向通信：命名管道通常是单向的，需要两个管道实现双向通信。
  

还可以使用消息队列实现（本人使用的是wsl2，微软不支持，故没有代码）

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。