所以我编写了一些代码来试验线程并进行一些测试。
代码应该创建一些数字，然后找到这些数字的平均值。
我认为到目前为止，向您展示我的内容会更容易。我期待两个线程的代码运行速度大约是其两倍。用秒表测量它我觉得它运行速度慢了6倍！编辑：现在使用计算机和clock（）函数来告诉时间。
void findmean(std::vector<double>*, std::size_t, std::size_t, double*);
int main(int argn, char** argv)
{
// Program entry point
std::cout << "Generating data..." << std::endl;
// Create a vector containing many variables
std::vector<double> data;
for(uint32_t i = 1; i <= 1024 * 1024 * 128; i ++) data.push_back(i);
// Calculate mean using 1 core
double mean = 0;
std::cout << "Calculating mean, 1 Thread..." << std::endl;
findmean(&data, 0, data.size(), &mean);
mean /= (double)data.size();
// Print result
std::cout << " Mean=" << mean << std::endl;
// Repeat, using two threads
std::vector<std::thread> thread;
std::vector<double> result;
result.push_back(0.0);
result.push_back(0.0);
std::cout << "Calculating mean, 2 Threads..." << std::endl;
// Run threads
uint32_t halfsize = data.size() / 2;
uint32_t A = 0;
uint32_t B, C, D;
// Split the data into two blocks
if(data.size() % 2 == 0)
{
B = C = D = halfsize;
}
else if(data.size() % 2 == 1)
{
B = C = halfsize;
D = hsz + 1;
}
// Run with two threads
thread.push_back(std::thread(findmean, &data, A, B, &(result[0])));
thread.push_back(std::thread(findmean, &data, C, D , &(result[1])));
// Join threads
thread[0].join();
thread[1].join();
// Calculate result
mean = result[0] + result[1];
mean /= (double)data.size();
// Print result
std::cout << " Mean=" << mean << std::endl;
// Return
return EXIT_SUCCESS;
}
void findmean(std::vector<double>* datavec, std::size_t start, std::size_t length, double* result)
{
for(uint32_t i = 0; i < length; i ++) {
*result += (*datavec).at(start + i);
}
}
我认为这段代码并不完美，如果您能提出改进方法，那么我也会对此感激不尽。
有些人建议为函数'findmean'创建一个局部变量。这就是我所做的：
void findmean(std::vector<double>* datavec, std::size_t start, std::size_t length, double* result)
{
register double holding = *result;
for(uint32_t i = 0; i < length; i ++) {
holding += (*datavec).at(start + i);
}
*result = holding;
}
我现在可以报告：代码运行时的执行时间与单个线程几乎相同。这是6倍的大改进，但肯定必须有一种方法使它几乎快两倍？
我已将优化设置为'O2' - 我将创建一个包含结果的表。
原始代码没有优化或寄存器变量： 1个主题：4.98秒，2个主题：29.59秒
添加了寄存器变量的代码： 1个线程：4.76秒，2个线程：4.76秒
使用reg变量和-O2优化： 1个线程：0.43秒，2个线程：0.6秒 2线程现在更慢？
根据Dameon的建议，这是在两个结果变量之间放置一大块内存： 1个线程：0.42秒，2个线程：0.64秒
TAS建议使用迭代器来访问向量的内容： 1个线程：0.38秒，2个线程：0.56秒
与Core i7 920（单通道内存4GB）相同： 1个线程：0.31秒，2个线程：0.56秒
与Core i7 920（双通道内存2x2GB）相同： 1个线程：0.31秒，2个线程：0.35秒
答案 0 :(得分：19)
为什么2个线程比1个线程慢6倍？
您遇到了false sharing的错误案例。
在摆脱错误共享之后，为什么2个线程不比1个线程快？
您的内存带宽会受到瓶颈。
虚假分享
这里的问题是每个线程正在访问相邻内存位置的result变量。它们很可能落在同一个高速缓存行上，因此每次线程访问它时，它都会在核心之间反弹高速缓存行。
每个线程都在运行此循环：
for(uint32_t i = 0; i < length; i ++) {
*result += (*datavec).at(start + i);
}
您可以看到result变量经常被访问（每次迭代）。因此，每次迭代时，线程都在为同一个高速缓存行而奋斗，这两个高速缓存行都保持result的两个值。
通常，编译器应将*result放入寄存器，从而删除对该内存位置的常量访问。但由于你从未开启优化，因此编译器很可能仍在访问内存位置，从而在循环的每次迭代中都会产生错误共享惩罚。
内存带宽：
一旦你消除了错误的共享并摆脱了6倍的减速，你没有得到改善的原因是因为你已经超出你的内存带宽。
确定您的处理器可能是4个内核，但它们都共享相同的内存带宽。总结一个数组的特定任务对每次内存访问都做了很少的（计算）工作。单个线程已足以最大化您的内存带宽。因此，进入更多线程不太可能让你有太大的改进。
简而言之，通过向其添加更多线程，你将无法以更快的速度对数组求和。
答案 1 :(得分：2)
正如其他答案中所述，您会看到结果变量的错误共享，但还有另一个位置发生这种情况。 std::vector<T>::at()函数（以及std::vector<T>::operator[]()）访问每个元素访问的向量长度。为避免这种情况，您应该切换到使用迭代器。此外，使用std::accumulate()将允许您利用正在使用的标准库实现中的优化。
以下是代码的相关部分：
thread.push_back(std::thread(findmean, std::begin(data)+A, std::begin(data)+B, &(result[0])));
thread.push_back(std::thread(findmean, std::begin(data)+B, std::end(data), &(result[1])));
和
void findmean(std::vector<double>::const_iterator start, std::vector<double>::const_iterator end, double* result)
{
*result = std::accumulate(start, end, 0.0);
}
这始终为我的32位上网本上的两个线程提供了更好的性能。
答案 2 :(得分：1)
更多线程并不意味着更快！创建和上下文切换线程存在开销，即使运行此代码的硬件也会影响结果。对于像这样的这样一个微不足道的工作，它可能是一个单一的线程。
答案 3 :(得分：0)
这可能是因为启动和等待两个线程的成本远远超过在单个循环中计算结果的成本。您的数据大小为128MB，现代处理器在单个循环中处理的数据并不多。