除非另有说明，否则 C++ 标准库对其类型提供以下保证:

(1) 读取操作(即处理 const 对象)是线程安全的。这意味着只要没有线程同时写入(应用非 const 操作)对象，多个线程就可以同时从对象读取而不会出现竞争条件。

(2) 多个线程可以同时读写任意对象，只要每个对象一次最多只能被一个线程访问。

标准库需要用户类型的相同保证。 (您可以在 GotW #95 中阅读这些内容或观看 Herb at C++ and Beyond 2012 对此的解释。)

现在我的问题是，如果下面的结论是正确的:因为 std::function 的 operator() 是一个 const 成员函数，它需要是线程安全的。如果在构造时传入的仿函数有一个 const operator() 成员函数，那么 std::function 对象可以假定它是线程安全的，并只是转发调用.然而，如果在构造时传递给它的仿函数有一个可变的 operator()，那么这个操作不需要是线程安全的，但是 std::function 仍然需要是，因为调用运算符仍然是常量。因此 std::function 必须在外部同步对存储的可变仿函数的调用，因此使用互斥锁。这意味着在将可变 lambda 传递给 std::function 的构造函数时会产生性能开销。

这个推理正确吗？如果是这样，当前的实现是否合规？

最佳答案

Herb 所谈论的关于标准库对数据竞争安全的保证的行为在 C++11 §17.6.5.9 中指定:

17.6.5.9 Data race avoidance [res.on.data.races]

1 This section specifies requirements that implementations shall meet to prevent data races (1.10). Every standard library function shall meet each requirement unless otherwise specified. Implementations may prevent data races in cases other than those specified below.

2 A C++ standard library function shall not directly or indirectly access objects (1.10) accessible by threads other than the current thread unless the objects are accessed directly or indirectly via the function’s arguments, including this.

3 A C++ standard library function shall not directly or indirectly modify objects (1.10) accessible by threads other than the current thread unless the objects are accessed directly or indirectly via the function’s non-const arguments, including this.

4 [ Note: This means, for example, that implementations can’t use a static object for internal purposes without synchronization because it could cause a data race even in programs that do not explicitly share objects between threads. —end note ]

5 A C++ standard library function shall not access objects indirectly accessible via its arguments or via elements of its container arguments except by invoking functions required by its specification on those container elements.

6 Operations on iterators obtained by calling a standard library container or string member function may access the underlying container, but shall not modify it. [ Note: In particular, container operations that invalidate iterators conflict with operations on iterators associated with that container. —end note ]

7 Implementations may share their own internal objects between threads if the objects are not visible to users and are protected against data races.

8 Unless otherwise specified, C++ standard library functions shall perform all operations solely within the current thread if those operations have effects that are visible (1.10) to users.

9 [ Note: This allows implementations to parallelize operations if there are no visible side effects. —end note ]

假设您将 lambda 闭包传递给 std::function - 通过构造函数或赋值运算符 - 然后调用该 function 的 运算符()。根据第 1 段，operator () 被允许“直接或间接通过函数的参数，包括 this”访问闭包对象。根据第 2 段，它可能不会更改 std::function 对象本身或闭包对象的状态，因为它们都是“通过函数的非常量参数直接或间接访问的，包括 这个。”这种行为很容易实现，无需任何类型的保护以防止同时线程访问，即锁定。

operator () 然后调用 lambda 闭包的 operator()，规则改变了:你的 lambda 的 operator () 不是标准的库函数，因此不受指定标准库函数行为的规则的约束。您可以根据语言规则对闭包对象做任何您想做的事情。

标准库保证它不会通过其操作引入任何数据竞争，但您应对您的代码可能引入的任何数据竞争负责。

关于c++ - std::function 在调用内部可变 lambda 时是否锁定互斥量？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/21766477/