虚拟表创建线程安全吗？

Question

首先，我知道从构造函数/析构函数中调用虚函数是一种不好的做法。 然而，这样做的行为，尽管可能令人困惑或不是用户所期望的，但仍然是明确定义的。

struct Base
{
    Base()
    {
        Foo();
    }
    virtual ~Base() = default;
    virtual void Foo() const
    {
        std::cout << "Base" << std::endl;
    }
};

struct Derived : public Base
{
    virtual void Foo() const
    {
        std::cout << "Derived" << std::endl;
    }
};

int main(int argc, char** argv) 
{
    Base base;
    Derived derived;
    return 0;
}

Output:
Base
Base

现在，回到我真正的问题。如果用户从不同线程的构造函数中调用虚函数会发生什么。有比赛条件吗？它是未定义的吗？ 或者换句话说。编译器设置 vtable 是线程安全的吗？

例子：

struct Base
{
    Base() :
        future_(std::async(std::launch::async, [this] { Foo(); }))
    {
    }
    virtual ~Base() = default;

    virtual void Foo() const
    {
        std::cout << "Base" << std::endl;
    }

    std::future<void> future_;
};

struct Derived : public Base
{
    virtual void Foo() const
    {
        std::cout << "Derived" << std::endl;
    }
};

int main(int argc, char** argv) 
{
    Base base;
    Derived derived;
    return 0;
}

Output:
?

Answer 1

首先摘录一些与此上下文相关的标准：

[defns.dynamic.type]

glvalue 所指的最衍生对象的类型 [示例：如果静态类型为“指向类B的指针”的指针p指向从B派生的类D的对象，则表达式*p的动态类型为“@ 987654333@"。参考文献的处理方式类似。 —结束示例]

[intro.object] 6.7.2.1

[..] 一个对象有一个类型。有些对象是多态的；实现生成与每个这样的对象相关联的信息 可以在程序执行期间确定该对象的类型。

[class.cdtor] 11.10.4.4

可以在构造或销毁期间调用成员函数，包括虚函数。当从构造函数或析构函数直接或间接调用虚函数时，包括在类的非静态数据成员的构造或销毁期间，并且调用适用的对象是正在构造的对象（称为 x ）或破坏，调用的函数是构造函数或析构函数类中的最终覆盖器，而不是在派生更多的类中覆盖它。 [..]

正如您所写，它明确定义了构造函数/析构函数中的虚函数调用如何工作 - 它们取决于对象的动态类型，以及动态类型与对象关联的信息，并且该信息在执行过程中更改。您使用哪种指针来“查看对象”无关紧要。考虑这个例子：

struct Base {
  Base() {
    print_type(this);
  }

  virtual ~Base() = default;

  static void print_type(Base* obj) {
      std::cout << "obj has type: " << typeid(*obj).name() << std::endl;
  }
};

struct Derived : public Base {
  Derived() {
    print_type(this);
  }
};

print_type 总是收到指向Base 的指针，但是当您创建Derived 的实例时，您会看到两行——一行带有“Base”，一行带有“Derived”。动态类型是在构造函数的最开始设置的，因此您可以调用虚函数作为成员初始化的一部分。

未指定如何或在何处存储此信息，但它与对象本身相关。

[..] 实现生成与每个此类对象相关联的信息 [..]

为了更改动态类型，必须更新此信息。这可能是编译器引入的一些数据，但对这些数据的操作仍然被内存模型覆盖：

[intro.memory] 6.7.1.3

内存位置要么是标量类型的对象，要么是相邻位域的最大序列 非零宽度。 [ 注意：语言的各种特性，例如引用和虚函数，可能涉及程序无法访问但由实现管理的额外内存位置。 — 尾注]

因此，与对象相关的信息会在某个内存位置中存储和更新。但那是发生了数据竞争：

[intro.races]

[..]
如果其中一个修改内存位置，而另一个读取或修改相同的内存位置，则两个表达式计算会发生冲突。
[..]
如果程序的执行包含两个潜在的并发冲突操作，则程序的执行包含数据竞争，其中至少一个不是原子的，并且都不会在另一个之前发生 [..]

动态类型的更新不是原子的，并且由于没有其他同步可以强制执行发生前的顺序，这是一个数据竞争，因此是 UB。

即使更新 是原子的，只要构造函数尚未完成，您仍然无法保证对象的状态，因此将其设为原子毫无意义。

---

更新

从概念上讲，它感觉就像对象在构造和销毁过程中呈现出不同的类型。然而，@LanguageLawyer 已向我指出，对象的 动态类型（更准确地说是指代该对象的泛左值）对应于 最衍生的类型，并且这种类型被明确定义并且不会改变。 [class.cdtor] 还包含有关此细节的提示：

[..] 调用的函数是构造函数或析构函数的类中的最终覆盖器，而不是在更多派生类中覆盖它。

因此，即使虚函数调用和 typeid 运算符的行为被定义好像对象具有不同的类型，但实际上并非如此。

也就是说，为了在对象的状态（或至少与该对象关联的某些信息）中实现指定的行为某事，必须进行更改。正如[intro.memory] 中所指出的，这些额外的内存位置确实是内存模型的主题。所以我仍然坚持我最初的评估，即这是一场数据竞赛。

Answer 2

我相信[class.base.init]/16：

可以为正在构建的对象调用成员函数（包括虚成员函数）。同样，正在构造的对象可以是typeid 运算符或dynamic_­cast 的操作数。但是，如果这些操作在所有 mem-initializers 之前在 ctor-initializer 中执行（或在从 ctor-initializer 直接或间接调用的函数中） 对于基类已经完成，程序有未定义的行为。

应该回答这个问题。但是，它有缺陷。解决方法是

但是，如果这些操作在 ctor-initializer 中执行（或在直接或间接从 ctor-initializer 调用的函数中）before s> 不是在基类的所有mem-initializers都完成后，程序有未定义的行为。

目前，该段落说只有在基类的 mem-initializers 完成之前调用成员函数时，行为才被定义，但不包括您的情况：当调用既不会在基类初始化完成之前发生，也不会在调用之前发生基类初始化完成。

Answer 3

是的。

严格来说，没有。您可能可以通过一些努力构建一个恶意示例，该示例至少在形式上不是线程安全的。但在实践中它仍然是线程安全的。

除了试图完全恶意地令人讨厌，特别是在你的问题的上下文中，它绝对是是。

一个对象要么根本不存在，要么正在构造，要么完全构造。唯一有点尴尬的状态是正在构建的状态。
有时不鼓励在部分构造的对象上从构造函数调用虚函数，但这样做是完全合法的，只要知道其中的含义。也就是说，同一个对象在不同的​​时间是不同的东西。

至于你的具体例子：你正在做的是，你调用一个函数，你捕获this，当时它引用Base类型的对象。线程最终运行时将使用什么类型的对象是毫无疑问的，因为它必须使用 this 的那个副本，仅此而已。

该标准并未准确定义如何使用继承和 vtable 以及所有这些（但这只是未指定，而不是未定义的行为）。在实践中，它通常是一个指向正在更新的静态结构的指针，并且在大多数架构（所有合理架构，就此而言）无论如何这都是原子操作。
因此，即使需要某种原子性，它实际上也应该存在。

不过，它甚至都不需要。捕获发生在一个线程中，即当前正在构造对象的线程，并且对象可能处于的状态只有一个，而且毫无疑问是什么。

Answer 4

发件人：https://isocpp.org/wiki/faq/strange-inheritance#calling-virtuals-from-ctors

您可以在构造函数中调用虚函数，但要小心。它可能无法达到您的预期。在构造函数中，虚拟调用机制被禁用，因为尚未发生从派生类的覆盖。对象是从基础构建的，“在派生之前基础”。

如果在异步函数被调用时“构造阶段”尚未完成，它将调用调用对象的函数。

编译器设置vtable，线程安全吗？

据我了解，它不是线程安全的，但除了分配器和初始化器之外，没有人应该修改该内存位置