Question

C ++ 11标准说明本地静态变量初始化它应该是线程安全的（http://en.cppreference.com/w/cpp/language/storage_duration#Static_local_variables）。我的问题是关于将lambda初始化为静态局部变量时究竟发生了什么？

让我们考虑以下代码：

#include <iostream>
#include <functional>

int doSomeWork(int input)
{
    static auto computeSum = [](int number)                                                                                                                                                                  
    {
      return 5 + number;
    };  
    return computeSum(input);
}

int main(int argc, char *argv[])
{
    int result = 0;
#pragma omp parallel
{
  int localResult = 0;
#pragma omp for
  for(size_t i=0;i<5000;i++)
  {
   localResult += doSomeWork(i);
  }
#pragma omp critical
{
   result += localResult;
}
}

std::cout << "Result is: " << result << std::endl;

return 0;
}

使用ThreadSanitizer编译使用GCC 5.4：

gcc -std=c++11 -fsanitize=thread -fopenmp -g main.cpp -o main -lstdc++

工作正常，ThreadSanitizer没有错误。现在，如果我更改lambda＆＃34; computeSum＆＃34;初始化为：

static std::function<int(int)> computeSum = [](int number)
{
  return 5 + number;
};

代码仍在编译，但ThreadSanitizer给了我一个警告，说有数据竞争：

WARNING: ThreadSanitizer: data race (pid=20887)
  Read of size 8 at 0x000000602830 by thread T3:
    #0 std::_Function_base::_M_empty() const /usr/local/gcc-5.4_nofutex/include/c++/5.4.0/functional:1834 (main+0x0000004019ec)
    #1 std::function<int (int)>::operator()(int) const /usr/local/gcc-5.4_nofutex/include/c++/5.4.0/functional:2265 (main+0x000000401aa3)
    #2 doSomeWork(int) /home/laszlo/test/main.cpp:13 (main+0x000000401242)
    #3 main._omp_fn.0 /home/laszlo/test/main.cpp:25 (main+0x000000401886)
    #4 gomp_thread_start ../../../gcc-5.4.0/libgomp/team.c:118 (libgomp.so.1+0x00000000e615)

  Previous write of size 8 at 0x000000602830 by thread T1:
    #0 std::_Function_base::_Function_base() /usr/local/gcc-5.4_nofutex/include/c++/5.4.0/functional:1825 (main+0x000000401947)
    #1 function<doSomeWork(int)::<lambda(int)>, void, void> /usr/local/gcc-5.4_nofutex/include/c++/5.4.0/functional:2248 (main+0x000000401374)
    #2 doSomeWork(int) /home/laszlo/test/main.cpp:12 (main+0x000000401211)
    #3 main._omp_fn.0 /home/laszlo/test/main.cpp:25 (main+0x000000401886)
    #4 gomp_thread_start ../../../gcc-5.4.0/libgomp/team.c:118 (libgomp.so.1+0x00000000e615)

  Location is global 'doSomeWork(int)::computeSum' of size 32 at 0x000000602820 (main+0x000000602830)

  Thread T3 (tid=20891, running) created by main thread at:
    #0 pthread_create ../../../../gcc-5.4.0/libsanitizer/tsan/tsan_interceptors.cc:895 (libtsan.so.0+0x000000026704)
    #1 gomp_team_start ../../../gcc-5.4.0/libgomp/team.c:796 (libgomp.so.1+0x00000000eb5e)
    #2 __libc_start_main <null> (libc.so.6+0x00000002082f)

  Thread T1 (tid=20889, running) created by main thread at:
    #0 pthread_create ../../../../gcc-5.4.0/libsanitizer/tsan/tsan_interceptors.cc:895 (libtsan.so.0+0x000000026704)
    #1 gomp_team_start ../../../gcc-5.4.0/libgomp/team.c:796 (libgomp.so.1+0x00000000eb5e)
    #2 __libc_start_main <null> (libc.so.6+0x00000002082f)

SUMMARY: ThreadSanitizer: data race /usr/local/gcc-5.4_nofutex/include/c++/5.4.0/functional:1834 std::_Function_base::_M_empty() const

在任何情况下，ThreadSanitizer报告数据竞争的代码需要执行5-10次，直到出现警告消息。

所以我的问题是：

之间存在概念上的区别吗？

static auto computeSum = [](int number){ reentrant code returing int };

和

static std::function<int(int)> computeSum = [](int number) {same code returning int};

是什么让第一个代码工作，第二个代码是数据竞争？

编辑＃1 ：似乎对我的问题进行了相当多的讨论。我发现Sebastian Redl的贡献最有帮助，因此我接受了这个答案。我只是想总结一下，以便人们可以参考这个。（请告诉我，如果这不适合Stack Overflow，我真的不会在这里问问题......）

为什么会举报数据竞赛？

在评论中（由MikeMB提出），该问题与TSAN的gcc实现中的错误有关（请参阅this和this链接）。这似乎是正确的：

如果我编译包含以下内容的代码：

static std::function<int(int)> computeSum = [](int number){ ... return int;};

使用GCC 5.4，机器代码如下：

  static std::function<int(int)> computeSum = [](int number)
  {
    return 5 + number;
  };
  4011d5:       bb 08 28 60 00          mov    $0x602808,%ebx
  4011da:       48 89 df                mov    %rbx,%rdi
  4011dd:       e8 de fd ff ff          callq  400fc0 <__tsan_read1@plt>
  ....

然而，对于GCC 6.3，它的内容为：

  static std::function<int(int)> computeSum = [](int number)                                                                                                                                             
  {
    return 5 + number;
  };
  4011e3:   be 02 00 00 00          mov    $0x2,%esi
  4011e8:   bf 60 28 60 00          mov    $0x602860,%edi
  4011ed:   e8 9e fd ff ff          callq  400f90 <__tsan_atomic8_load@plt>

我不是机器代码的大师，但看起来在GCC 5.4版本中，__tsan_read1@plt用于检查静态变量是否已初始化。相比之下，GCC 6.3生成__tsan_atomic8_load@plt。我猜第二个是正确的，第一个导致误报。

如果我在没有ThreadSanitizer的情况下编译版本，GCC 5.4会生成：

static std::function<int(int)> computeSum = [](int number)
{                                                                                                                                                                                                        
  return 5 + number;
};
400e17:     b8 88 24 60 00          mov    $0x602488,%eax
400e1c:     0f b6 00                movzbl (%rax),%eax
400e1f:     84 c0                   test   %al,%al
400e21:     75 4a                   jne    400e6d <doSomeWork(int)+0x64>
400e23:     bf 88 24 60 00          mov    $0x602488,%edi
400e28:     e8 83 fe ff ff          callq  400cb0 <__cxa_guard_acquire@plt>

和GCC 6.3：

  static std::function<int(int)> computeSum = [](int number)
  {                                                                                                                                                                                                      
    return 5 + number;
  };
  400e17:   0f b6 05 a2 16 20 00    movzbl 0x2016a2(%rip),%eax        # 6024c0 <guard variable for doSomeWork(int)::computeSum>
  400e1e:   84 c0                   test   %al,%al
  400e20:   0f 94 c0                sete   %al
  400e23:   84 c0                   test   %al,%al
  400e25:   74 4a                   je     400e71 <doSomeWork(int)+0x68>
  400e27:   bf c0 24 60 00          mov    $0x6024c0,%edi
  400e2c:   e8 7f fe ff ff          callq  400cb0 <__cxa_guard_acquire@plt>

如果我使用auto代替std::function ，为什么没有数据竞争？

你可能需要在这里纠正我，但可能是编译器＆＃34; inlines＆＃34;自动对象，因此无需对静态对象是否已初始化进行簿记。

static auto computeSum = [](int number){ ... return int;};

产生

  static auto computeSum = [](int number)
  400e76:   55                      push   %rbp                                                                                                                                                          
  400e77:   48 89 e5                mov    %rsp,%rbp
  400e7a:   48 89 7d f8             mov    %rdi,-0x8(%rbp)
  400e7e:   89 75 f4                mov    %esi,-0xc(%rbp)
  //static std::function<int(int)> computeSum = [](int number)
  {
    return 5 + number;
  };
  400e81:   8b 45 f4                mov    -0xc(%rbp),%eax
  400e84:   83 c0 05                add    $0x5,%eax
  400e87:   5d                      pop    %rbp
  400e88:   c3                      retq

Answer 1

C ++标准保证本地静态的初始化，无论多么复杂，都是线程安全的，因为初始化代码只运行一次，并且在初始化完成之前没有线程将运行初始化代码。

此外，它保证从线程安全的角度调用std :: function是一个读操作，这意味着任意数量的线程可以同时执行它，只要std :: function对象是没有同时修改。

通过这些保证，并且因为您的代码不包含访问共享状态的任何其他内容，所以它应该是线程安全的。如果它仍然触发TSan，那么某处

的错误。

最有可能的是，GCC使用非常棘手的原子代码进行静态初始化保证，而TSan无法识别它是否安全。换句话说，它是TSan中的一个错误。确保您使用的是最新版本的两种工具。（具体来说，似乎TSan在某种程度上错过了某种障碍，确保std::function的初始化实际上对其他线程可见。）
不太可能，GCC的初始化魔法实际上是不正确的，并且这里存在真正的竞争条件。我找不到任何错误报告，因为5.4有一个后来修复过的bug。但是你可能想尝试使用更新版本的GCC。（最新的是6.3。）
有人建议std::function的构造函数可能有一个错误，它以不安全的方式访问全局共享方式。但即使这是真的，也没关系，因为你的代码不应该多次调用构造函数。
GCC中可能存在一个错误，它将包含静态的函数内联到OpenMP并行循环中。也许这会导致重复静态或破坏安全初始化代码。为此必须检查生成的组件。

顺便说一下，代码的第一个版本是不同的，因为它完全是微不足道的。在-O3下，GCC实际上会在编译时完全计算循环，有效地将主函数转换为

std::cout << "Result is: " << 12522500 << std::endl;

https://godbolt.org/g/JDRPQV

即使它没有这样做，也没有对lambda进行初始化（变量只是填充的单个字节），因此没有对任何内容的写访问，也没有机会进行数据竞争。 / p>

Answer 2

到目前为止，这两个答案的推理都是错误的。

它与lambda 函数指针无关。原因是：如果函数不访问不受保护的共享数据，那么它是安全的。对于问题中定义的auto computeSum= ..，这很简单，ThreadSanitizer可以轻松证明它不访问任何共享数据。然而，在std::function的情况下，代码变得有点复杂，并且消毒剂要么被混淆，要么根本没有达到证明它仍然相同的程度！只是放弃了，看到了std::function。或者它有错误 - 或者更糟糕的是，std::function是错误的！

让我们做这个实验：在全局命名空间定义int global = 100;，然后在第一个lambda中执行++global;。看看消毒剂现在说了什么。我相信它会给出警告/错误！这足以证明它与lambda 函数指针无关，正如其他答案所声称的那样。

关于你的问题：

本地静态lambda线程的初始化是否安全？

是（从C ++ 11开始）。请搜索此站点以获取更详细的答案。这已经多次讨论过了。

Answer 3

将任务分成两部分：

首先，静态变量初始化期间lambda和闭包之间是否存在差异？

是的，有区别，但这并不重要，因为gcc确保安全。和threadsanitizer可能会发出警告，因为它不足以分析std :: function构造函数。

第一个是lambda，第二个是闭包。

lambda包含一个字段，它是一个函数指针，可能不会导致种族问题，因为它是原子的。

但是闭包是一个带有封闭变量的函数指针，std :: function中有多个字段，因此无法原子更新。

第二，lambda / closure调用期间lambda和closure之间有区别吗？

不，他们完全一样。你的函数应该保护所使用的共享数据，无论它是lambda还是闭包。

C ++多线程：是本地静态lambda线程安全的初始化吗？

3 个答案: