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;
}

用 GCC 5.4 编译，使用 ThreadSanitizer:

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

工作正常，ThreadSanitizer 没有错误。现在，如果我将初始化 lambda "computeSum"的行更改为:

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，为什么没有数据竞争？

您可能需要在这里纠正我，但编译器可能会“内联”自动对象，因此无需记录静态对象是否已初始化。

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

最佳答案

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

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

通过这些保证，并且由于您的代码不包含任何其他访问共享状态的内容，因此它应该是线程安全的。如果它仍然触发 TSan，则 某处 有一个错误:

• 很可能，GCC 使用非常棘手的原子代码来保证静态初始化，TSan 无法将其识别为安全的。换句话说，这是 TSan 中的一个错误。确保您尽可能使用这两种工具的最新版本。 (具体来说，TSan 似乎缺少某种屏障，以确保 std::function 的初始化实际上对其他线程可见。)
• 不太可能的是，GCC 的初始化魔法实际上是不正确的，这里存在真正的竞争条件。我找不到任何错误报告，大意是 5.4 有这样一个错误，后来被修复了。但是您可能还是想尝试使用较新版本的 GCC。 (最新的是 6.3。)
• 有人提出 std::function 的构造函数可能有一个错误，它以不安全的方式访问全局共享方式。但即使这是真的，也没关系，因为您的代码不应多次调用构造函数。
• 在将包含静态变量的函数内联到 OpenMP 并行循环中时，GCC 可能存在错误。也许这会导致静态重复，或破坏安全初始化代码。为此需要检查生成的程序集。

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

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

https://godbolt.org/g/JDRPQV

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

关于C++ 多线程 : is initialization of a local static lambda thread safe?，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42062557/