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编译，使用ThreadManitizer：
gcc -std=c++11 -fsanitize=thread -fopenmp -g main.cpp -o main -lstdc++
工作正常，ThreadManitizer没有错误。现在，如果我将lambda"computeSum"初始化的行更改为：
static std::function<int(int)> computeSum = [](int number)
{
return 5 + number;
};
代码仍然可以编译，但ThreadManitizer给了我一个警告，说存在数据竞争：
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
在任何情况下，ThreadManitizer报告数据竞争的代码都需要执行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实现中的一个错误有关(请参阅此链接)。这似乎是正确的：
如果我编译包含以下内容的代码：
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。我想第二个是正确的，第一个会导致假阳性。
如果我编译没有ThreadManitizer的版本，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，为什么没有数据竞争？
您可能需要纠正我的错误，但编译器可能会"内联"auto对象，因此不需要对静态对象是否已初始化进行记账。
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：：函数是一个读取操作，这意味着只要std：函数对象没有同时修改，任意数量的线程都可以同时执行。
通过这些保证，并且因为您的代码不包含任何访问共享状态的其他内容，所以它应该是线程安全的。如果它仍然触发TSan，则某个地方有一个错误：
- 最有可能的是，GCC使用了非常棘手的原子代码来保证静态初始化，TSan无法将其确定为安全的。换句话说，这是TSan中的一个bug。确保您使用的是这两种工具的最新版本。(具体来说，TSan似乎在某种程度上缺少了某种屏障，从而确保
std::function的初始化对其他线程实际上是可见的。) - 不太可能的是，GCC的初始化魔法实际上是不正确的，这里有一个真正的竞争条件。我找不到任何关于5.4有这样一个后来被修复的错误的报告。但是，您可能无论如何都想尝试使用较新版本的GCC。(最新版本为6.3。)
- 有人认为
std::function的构造函数可能存在以不安全的方式访问全局共享方式的错误。但是，即使这是真的，也不重要，因为代码不应该多次调用构造函数 - GCC中可能存在将包含静态的函数内联到OpenMP并行循环中的错误。也许这会导致静态数据的重复，或者破坏安全的初始化代码。为此，有必要对生成的程序集进行检查
顺便说一句，代码的第一个版本不同，因为它完全是琐碎的。在-O3下，GCC实际上会在编译时完全计算循环，有效地将主函数转换为
std::cout << "Result is: " << 12522500 << std::endl;
https://godbolt.org/g/JDRPQV
即使它没有这样做，也没有对lambda进行初始化(变量只是一个字节的填充)，因此没有对任何内容的写访问，也没有数据竞争的机会。
到目前为止公布的两个答案的推理都是错误的。
它与lambda是函数指针无关。原因是：如果一个函数不访问未受保护的共享数据，那么它是安全的。在问题中定义的auto computeSum= ..的情况下，这很简单，ThreadManitizer很容易证明它不会访问任何共享的数据。然而，在std::function的情况下，代码变得有点复杂，并且消毒剂要么被混淆，要么根本没有达到证明它仍然是的程度！它只是放弃了，看到了std::function。或者它有错误—或者更糟的是，std::function有缺陷！
让我们来做这个实验：在全局名称空间中定义int global = 100;，然后在第一个lambda中执行++global;。现在看看消毒液怎么说。我相信它会发出警告/错误！这足以证明它与lambda是函数指针无关，正如其他答案所声称的那样。
至于你的问题：
初始化本地静态lambda线程是否安全？
是(从C++11开始)。请搜索此网站以获取更详细的答案。这已经讨论过很多次了。
将任务分成两部分：
首先，在静态变量初始化过程中，lambda和闭包之间有区别吗
是的，有区别，但这并不重要，因为gcc确保了安全。而threadsancer可能会发出警告，因为它不够强大，无法分析std:：函数构造函数。
第一个是lambda，第二个是闭包。
lambda包含一个单独的字段，该字段是函数指针，可能不会导致争用问题，因为它是原子字段。
但是闭包是一个带有封闭变量的函数指针，std：：function中有超过1个字段，因此无法进行原子更新。
其次，在lambda/闭包调用过程中，lambda和闭包之间有区别吗
不，它们完全一样。函数应该保护所使用的共享数据，无论是lambda还是闭包。