第 7 章：进程间通信

在本章中，您将了解Linux提供的进程间通信（IPC）接口。通过它们，您将全面了解如何满足系统和软件需求。首先，您将学习消息队列（MQs），这是对[第3章]中关于管道的讨论的延续。此外，我们将详细分析信号量和互斥锁同步技术的工作原理。我们将向您介绍C++20在这一领域的一些新特性，这些特性易于使用，您无需自行实现。

接着，我们将介绍共享内存技术，它可以让您快速传输大量数据。最后，如果您对网络上计算机系统间的通信感兴趣，您将了解套接字和网络通信协议。有了这些知识，我们将为您提供一些实用的命令，以便您在网络上管理自己的系统。

我们将在[第9章]中继续本章开始的讨论。

本章将涵盖以下主要主题：

介绍MQs和发布/订阅机制
通过信号量和互斥锁保证原子操作
使用共享内存
通过网络套接字进行通信

技术要求

为了运行代码示例，您需要准备以下内容：

一台能够编译和执行C++20的基于Linux的系统（例如，Linux Mint 21）
GCC 12.2编译器（https://gcc.gnu.org/git/gcc.git gcc-source）并使用-std=c++2a、-lpthread和-lrt标志
对于所有示例，您也可以使用 https://godbolt.org/
代码链接：https://share.xueplus.com/s/9fXDVv-4fijh.html

介绍MQs和发布/订阅机制

我们很高兴再次讨论IPC主题。上次我们在[第3章]中讨论了管道，并使用了一些代码示例。您了解了进程间交换数据的基本机制，但如您所记，存在一些阻塞点。就像任何编程工具一样，管道有其特定用途——它们快速，可以帮助您从相关（forked）进程（通过匿名管道）和不相关进程（通过命名管道）发送和接收数据。

同样，我们可以使用MQs传输数据，它们也适用于相关和不相关的进程。它们提供了将单个消息发送到多个接收进程的能力。但正如您所见，管道在发送和接收二进制数据方面是原始的，而MQs则引入了消息的概念。传输策略仍然在调用过程中配置——队列名称、大小、信号处理、优先级等——但其策略和序列化数据的能力现在由MQ的实现掌握。这为程序员提供了一种相对简单且灵活的方式来准备和处理数据消息。根据我们的软件设计，我们可以轻松实现异步的发送接收数据传输或发布/订阅（pub/sub）机制。Linux为MQs提供了两种不同的接口——一种来自System V，用于本地服务器应用，另一种来自POSIX，用于实时应用。出于本书的目的，我们更倾向于使用POSIX接口，因为它在配置上更丰富、更清晰。它也是一种基于文件的机制，正如我们在[第1章]中讨论的，您可以通过以下方式找到一个已挂载的队列：

$ ls /dev/mqueue

此接口可通过操作系统实时函数库librt获得，因此您需要在编译时链接它。MQ本身可以如下可视化：

图 7.1 – 通过 MQ 表示 IPC

让我们来看一个示例，我们从一个进程发送数据到另一个进程。示例数据已经存储在文件中，并加载通过MQ发送。

constexpr auto MAX_SIZE = 1024;
string_view QUEUE_NAME  = "/test_queue";

我们将初始配置和队列名称作为路径名一起设置：

void readFromQueue() {
...
    mqd_t          mq   = { 0 };
    struct mq_attr attr = { 0 };
    array<char, MAX_SIZE> buffer{};
    attr.mq_flags = 0;
    attr.mq_maxmsg = 10;
    attr.mq_msgsize = MAX_SIZE;
    attr.mq_curmsgs = 0;
    if (mq = mq_open(QUEUE_NAME.data(), O_CREAT | O_RDONLY,
                     0700, &attr); mq > -1) { // {1}
        for (;;) {
            if (auto bytes_read = mq_receive(mq,
                                             buffer.data(),
                                             buffer.size(),
                                             NULL);
                                  bytes_read > 0) { // {2}
                buffer[bytes_read] = '\0';
                cout << "Received: "
                     << buffer.data()
                     << endl; // {3}
            }
            else if (bytes_read == -1) {
                cerr << "Receive message failed!";
            }

对MQ进行了额外的配置，并准备好接收端。调用mq_open()函数以在文件系统上创建MQ并打开其读取端。通过一个无限循环，当从二进制文件读取数据时接收数据，并打印出来（前面代码中的标记{2}和{3}），直到文件完全消耗。然后，关闭接收端和读取端（以下代码中的标记{4}）。如果没有其他事情要做，通过mq_unlink()从文件系统中删除MQ：

            else {
                cout << "\n\n\n***Receiving ends***"
                     << endl;
                mq_close(mq); // {4}
                break;
            }
        }
    }
    else {
        cerr << "Receiver: Failed to load queue: "
             << strerror(errno);
    }
    mq_unlink(QUEUE_NAME.data());
}

这个示例是用两个线程实现的，但也可以用两个进程以相同方式完成。MQ的功能将保持不变。我们再次调用mq_open()并打开MQ以进行写入（以下代码中的标记{5}）。创建的队列最多可容纳10条消息，每条消息可达1024字节大小——这是通过前面代码片段中的MQ属性定义的。如果您不希望MQ操作阻塞，可以在属性中使用O_NONBLOCK标志，或者在mq_receive()调用之前使用mq_notify()。这样，如果MQ为空，读取器将被阻塞，但mq_notify()将在消息到达时触发信号，进程将恢复。

然后，使用测试数据打开本地存储的文件，并从中读取（以下代码中的标记{6}和{7}）。当我们读取时（您也可以使用std::ofstream），我们通过MQ发送其内容（以下代码中的标记{8}）。消息的优先级最低，即0。在队列中有更多消息的系统中，我们可以设置更高的优先级，它们将按降序处理。最大值可以从sysconf(_SC_MQ_PRIO_MAX)中看到，对于Linux，这是32768，但POSIX为了符合其他操作系统的要求，也强制从0到31的范围。让我们检查以下代码片段：

void writeToQueue() {
...
   if (mq = mq_open(QUEUE_NAME.data(), O_WRONLY,
                     0700, NULL); mq > -1) { // {5}
        int fd = open("test.dat", O_RDONLY); // {6}
        if (fd > 0) {
            for (;;) {
                // This could be taken from cin.
                array<char, MAX_SIZE> buffer{};
                if (auto bytes_to_send =
                        read(fd,
                             buffer.data(),
                        buffer.size());
                             bytes_to_send > 0) { // {7}
                    if (auto b_sent =
                            mq_send(mq,
                                    buffer.data(),
                                    buffer.size(),
                                    0);
                                    b_sent == -1) {// {8}
                        cerr << "Sent failed!"
                             << strerror(errno);
                    }

然后，我们发送一个零大小的消息来表示通信的结束（以下代码中的标记{9}）：

...
                else if (bytes_to_send == 0) {
                    cout << "Sending ends...." << endl;
                    if (auto b_sent =
                            mq_send(mq,
                                    buffer.data(),
                                    0,
                                    0); b_sent == -1) {
                                    // {9}
                        cerr << "Sent failed!"
                             << strerror(errno);

结果如下（从文件中打印的数据为了可读性而减少）：

Thread READER starting...
Thread WRITER starting...
Sending ends....
Received: This is a testing file...
Received: ing fileThis is a testing file...
***Receiving ends***
Main: program completed. Exiting.

这是一个非常简单的示例，考虑到我们只有两个工作器——readFromQueue()和writeToQueue()。MQs允许我们扩展并执行多对多通信。这种方法可以在许多嵌入式系统中找到，因为它也符合实时要求，并且不需要使用任何同步原语。许多微服务架构和无服务器应用都依赖于它。在下一节中，我们将讨论基于MQs的最流行模式之一。

发布/订阅机制

您可能已经意识到，当扩展时，一个MQ可能会成为瓶颈。正如您在前一个示例中观察到的，存在消息数量和大小的限制。另一个问题是，消息一旦被消费，就会从队列中移除——一次只能有一个消费者消费给定的消息。数据提供者（生产者）还必须管理正确的消息地址，这意味着添加额外的数据以帮助消费者识别消息发送给谁，每个消费者都必须遵循该策略。

首选的方法是为每个消费者创建一个单独的MQ。生产者将事先知道这些MQ，要么在编译时（所有MQ由系统程序员在数据段中列出），要么在运行时（每个消费者在启动时发送其MQ路径名，生产者将处理这些信息）。这样，消费者就是在订阅从给定生产者那里接收数据，而生产者则将其数据发布到它所知道的所有MQ。因此，我们称之为发布-订阅机制。

当然，具体实现可能会有所不同，这取决于软件设计，但理念将保持不变。此外，可能有多个生产者向多个消费者发送数据，我们称这是多对多实现。请看下面的图表：

图 7.2 – 发布/订阅机制的 MQ 实现表示

当我们朝着进程解耦前进时，我们使系统更加灵活。随着订阅者不再浪费计算时间来识别消息是否针对他们，扩展变得更容易。添加新的生产者或消费者而不干扰其他人也变得容易。MQ在操作系统级别上实现，因此我们可以将其视为一个健壮的IPC机制。不过，一个可能的缺点是，生产者通常不会从订阅者那里收到任何健康信息。这导致MQ充满了未消费的数据，生产者被阻塞。因此，在更抽象的层面上实现了额外的实现框架，用于处理此类用例。我们鼓励您额外研究观察者和消息代理设计模式。内部开发的发布/订阅机制通常是基于它们构建的，并不总是通过MQs实现的。尽管如此，正如您可能已经猜到的，通过这种机制发送大量数据将是一个缓慢的操作。因此，我们需要一种工具来快速获取大量数据。不幸的是，这需要额外的同步管理以避免类似[第6章]中讨论的数据竞争。下一节将讨论同步原语。

通过信号量和互斥锁保证原子操作

让我们试着聚焦一个共享资源，看看在CPU中会发生什么。我们将提供一种简单而有效的方式来解释数据竞争从何而来。这已在[第6章]中进行了详尽的讨论。我们在这里学到的一切都应该被视为一种补充，但并行和并发处理的分析方法与以前相同。但现在，我们关注具体的低级问题。

让我们仔细看看以下代码片段：

int shrd_res = 0; // 某个共享资源。
void thread_func(){
    shrd_res ++;
    std::cout << shrd_res;
}

这是一个非常简单的代码片段，其中一个变量被递增并打印出来。根据C++标准，在多线程环境中，这样的修改是未定义行为。让我们看看怎么回事——而不是在这里讨论进程的内存布局，我们将一边分析它的伪汇编代码：

...
int shrd_res = 0;      store 0
shrd_res++;            load value
                       add 1
                       store value
std::cout << shrd_res; load value
...

假设这个递增过程在一个线程函数中，且有不止一个线程在执行它。add 1指令是在加载的值上执行的，而不是在shrd_res的实际内存位置上。前面的代码片段将被多次执行，很可能是并行执行的。如果我们注意到线程是一组指令，直觉会告诉我们这些指令是以整体的方式执行的。换句话说，每个线程例程应该在不受干扰的情况下运行，这通常是这样的。然而，有一个小细节我们应该记住——CPU被设计成保持小延迟。它不是为数据并行而构建的。因此，打个比方，它的主要目标是装载大量的小任务。我们的每个线程都在不同的处理器上执行；这可能是不同的CPU、CPU线程或CPU核心——这真的取决于系统。如果处理器（CPU、核心或线程）的数量小于N，那么剩余的线程将排队等待直到有处理器空闲。

现在，初始线程的指令已经加载到那里并按原样执行。即使CPU核心在架构上相同，它们的目标是尽快执行。这意味着由于多种硬件波动，它们的速度不可能相同。但shared_resource是一个变量，也就是…一个共享资源。这意味着谁先增加它谁就会这样做，其他人将跟随。即使我们不关心std::cout的结果（例如，打印顺序不再是顺序的），我们仍然有需要担心的事情。你可能已经猜到了！我们不知道我们实际上要增加的是什么值——它会是shared_resource的最后存储值还是新递增的值？这是怎么发生的？

让我们看看：

Thread 1: shrd_res++; T1: load value
                      T1: add 1
Thread 2: shrd_res++; T2: load value
                      T2: add 1
                      T2: store value
                      T1: store value

你跟上了吗？Thread 1的指令序列被打断了，因为Thread 2的执行。现在，我们能预测将打印什么吗？这被称为未定义行为。在某些情况下，它会是因为Thread 2从未执行，因为最后存储在shared_resource中的值将是在以下过程中递增的：

T1: add 1

换句话说，我们丢失了一个递增。没有任何指令告诉CPU这两个过程必须分别调用并连续执行。应该清楚的是，可能存在有限数量的指令组合，所有这些都会导致意外行为，因为它取决于硬件的状态。这种操作被称为非原子的。为了正确处理并行性，我们需要依靠原子操作！软件开发者的工作是考虑这一点，并告知CPU这样的指令集。互斥锁和信号量等机制被用来管理原子范围。我们将在接下来的部分中彻底分析它们的作用。

信号量

如果您向多个行业的人们提出一个关于信号量是什么的调查，您会得到不同的答案。机场的工作人员可能会告诉您，这是一种通过使用旗帜向某人发出信号的系统。一名警察可能会告诉您这只是一个交通信号灯。向火车司机询问可能会得到类似的回答。有趣的是，这正是我们的信号量来源。总的来说，这些答案应该暗示您，这是一种信号机制。

重要说明

编程信号量是由Edsger Dijkstra发明的，主要用于防止竞态条件。它们帮助我们信号指示资源是否可用，以及有多少给定类型的共享资源单位可用。

就像前面提到的信号机制一样，信号量并不能保证代码无误，因为它们并不阻止进程或线程获取资源单位——它们只是通知。就像火车可能会忽略信号，继续前往被占用的铁轨，或者汽车可能会在繁忙的十字路口继续前行一样，这可能是灾难性的！再次强调，软件工程师的任务是弄清楚如何为系统的良好健康使用信号量。因此，让我们开始使用它们。

Dijkstra为我们提供了两个主要函数，围绕着关键部分：P(S)和V(S)。您可能知道，他是荷兰人，所以这些函数的名字来自荷兰语单词尝试和增加（分别是probeer和vrhoog），其中S是信号量变量。仅从它们的名字，您已经对它们将要做什么有了一个概念。让我们用伪代码看看它们：

unsigned int S = 0;
V(S):
    S=S+1;
P(S):
    while(S==0):
        // 无操作。
    S = S – 1;

所以，P(S)将不断检查信号量是否已经表示资源可用——信号量被递增。一旦S被递增，循环就会停止，信号量值会减少以执行其他代码。基于递增的值，我们识别出两种类型的信号量：二进制和计数。二进制信号量常被误认为互斥锁（mutex）机制。逻辑是一样的——例如，资源是否可自由访问和修改——但技术的本质是不同的，正如我们之前解释的，没有什么能阻止一些糟糕的并发设计忽略信号量。我们会马上讨论到这一点，但现在，让我们关注信号量的作用。在我们开始编写代码之前，让我们声明一下，在类Unix操作系统上有几种信号量接口。使用的选择取决于抽象级别和标准。例如，并不是每个系统都有POSIX，或者它没有完全暴露。由于我们将专注于C++20的使用，我们将仅将下一个示例用作参考。

让我们看看Linux上两种常见的信号量接口。第一个是未命名信号量——我们可以通过以下接口来展示它：

sem_t sem;
sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_destroy(sem_t *sem);
int sem_post(sem_t *sem);
int sem_wait(sem_t *sem);

sem变量是信号量，它分别通过sem_init()和sem_destroy()进行初始化和去初始化。P(S)函数由sem_wait()表示，V(S)函数由sem_post()表示。还有sem_trywait()，如果您想在递减不立即发生时报告错误，以及sem_timedwait()，这是一个阻塞调用，用于递减可能发生的时间窗口。这看起来很清楚，除了初始化部分。您可能已经注意到了value和pshared参数。第一个显示了信号量的初始值。例如，二进制信号量可以是0或1。第二个更有趣。

正如您可能记得的，在[第2章]中我们讨论了内存段。想象一下，我们在数据、BSS或堆上创建信号量。然后，它只会对单个进程中的线程全局可见，但无法在进程之间共享。问题是如何用它来进行进程同步；pshared正是为此目的使用的。如果它被设置为0，那么信号量就是本地的，用于进程，但如果它被设置为非零值，那么它就是跨进程共享的。关键是在如shmem的全局可见的内存区域上创建信号量，包括文件系统作为共享资源池。这里是命名信号量的概述：

命名信号量在进程创建者之外可见，因为它位于文件系统中，通常在/dev/shm下。我们将其视为一个文件。例如，以下代码将创建一个名为/sem的信号量，权限为0644——它只能被其所有者读写，但只能被其他人读取，并且直到以后通过代码移除时，它将在文件系统上可见：
```
sem_t *global_sem = sem_open("/sem", O_CREAT, 0644,
  0); 
```
P(S)和V(S)调用保持不变。我们完成后，必须关闭文件，并在不再需要时移除它：
```
sem_close(global_sem);
sem_unlink("/sem"); 
```