C+中的多线程程序+；显示与串行设备相同的性能 我只想用C++编写一个简单的程序，它创建两个线程，每个线程都用整数（0, 1, 4，9，……）填充向量。 这是我的密码： #include <iostream> #include <vector> #include <functional> #include <thread> #include <time.h> #define MULTI 1 #define SIZE 10000000 void fill(std::vector<unsigned long long int> &v, size_t n) { for (size_t i = 0; i < n; ++i) { v.push_back(i * i); } } int main() { std::vector<unsigned long long int> v1, v2; v1.reserve(SIZE); v2.reserve(SIZE); #if !MULTI clock_t t = clock(); fill(v1, SIZE); fill(v2, SIZE); t = clock() - t; #else clock_t t = clock(); std::thread first(fill, std::ref(v1), SIZE); fill(v2, SIZE); first.join(); t = clock() - t; #endif std::cout << (float)t / CLOCKS_PER_SEC << std::endl; return 0; } #包括 #包括 #包括 #包括 #包括 #定义多个1 #定义大小10000000 空隙填充（标准：向量和v，尺寸） { 对于（尺寸i=0；i

fill函数将运行得非常快，线程开销可能与执行时间一样长

---

将填充替换为需要花费大量时间才能执行的内容。作为第一步，使用

std:：this_thread:：sleep_for

在i7上使用MSVC2015执行代码时，我观察到：

• 在调试模式下，多线程是14秒，而单线程是26秒。因此速度几乎是原来的两倍。结果与预期一致
• 在发布模式下，多线程是0.3，而在单线程模式下是0.2，所以正如您所报告的，它的速度较慢

这表明您的问题与以下事实有关：与创建线程的开销相比，优化的

fill（）

太短

还要注意的是，即使在

fill（）

中没有足够的工作要做（例如，未优化的版本），多线程也不会将时间乘以2。多线程将增加多核处理器上每秒的总吞吐量，但单独执行的每个线程可能会比通常运行得慢一点

编辑：附加信息

多线程性能取决于许多因素，其中包括处理器上的内核数量、测试期间运行的其他进程使用的内核，以及多线程任务的配置文件（即内存与计算）

为了说明这一点，这里给出了一个非正式基准测试的结果，该结果表明，对于内存密集型计算，单个线程吞吐量的下降要比浮点密集型计算快得多，而全局吞吐量的增长要慢得多（如果有的话）：

对每个线程使用以下函数：

// computation intensive
void mytask(unsigned long long loops)
{
    volatile double x; 
    for (unsigned long long i = 0; i < loops; i++) {
        x = sin(sqrt(i) / i*3.14159);
    }
}

//memory intensive
void mytask2(vector<unsigned long long>& v, unsigned long long loops)
{
    for (unsigned long long i = 0; i < loops; i++) {
        v.push_back(i*3+10);
    }
}

//计算密集型
void mytask（无符号长循环）
{
挥发性双x；
for（无符号长i=0；i

大多数建议都是正确的：只有在线程cpu负载（在您的情况下是乘法i*i）比共享内存访问负载（在您的情况下是v.push_back）更重要的情况下，线程化任务才能提高执行时间。 您可以尝试使用此代码。您将看到线程的好处。 您可以使用unix命令

>time ./a.out 

以便更轻松地对代码计时

#include <iostream>
#include <vector>
#include <functional>
#include <thread>
#include <time.h>
#include <math.h>

#define MULTI 1
#define SIZE 10000000

void fill(std::vector<unsigned long long int> &v, size_t n)
{
    int sum = 0;
    for (size_t i = 0; i < n; ++i) {
        for (size_t j = 0; j < 100; ++j) {
            sum += sqrt(i*j);
        }
    }
    v.push_back(sum);
}

int main()
{
    std::vector<unsigned long long int> v1, v2;
    v1.reserve(SIZE);
    v2.reserve(SIZE);
    #if !MULTI
    fill(v1, SIZE);
    fill(v2, SIZE);
    #else
    std::thread first(fill, std::ref(v1), SIZE);
    std::thread second(fill, std::ref(v2), SIZE);

    first.join();
    second.join();
    #endif
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#定义多个1
#定义大小10000000
空隙填充（标准：向量和v，尺寸）
{
整数和=0；
对于（尺寸i=0；i

测试共享是否错误的一种方法是让fill函数执行一个新的函数来创建向量，然后填充向量，然后返回指向向量的指针（可能通过引用参数）。这可能会修复任何错误共享，当两个线程修改恰好位于同一缓存线上的不同数据时会发生这种情况。@Kyle抱歉，这不可能。我错过了这两个向量。无论如何，

push_back

将需要一个锁。该程序使用这两个线程几乎不涉及计算时间。执行时间基本上只是硬件内存缓存体系结构的一个函数。两个长的连续顺序写入可能与两个交错顺序写入一样快或更快。

man clock（）：clock（）函数返回程序使用的处理器时间的近似值。

我邀请您思考“处理器时间”的含义。您在此代码中运行的是内存子系统，而不是处理器。您只有一个。它还通过它触发的虚拟内存分页进行序列化，您在首次寻址内存时支付RAM分配。与优化代码中的内存写入瓶颈相比，线程开销最小。当多线程时ry写入不同的地址段同步内存写入会产生额外的开销。当每个线程都是计算密集型而不是内存密集型时，多线程操作最有效。@doug是的，这是真的。我编辑了两种效果的答案，并展示了一些实验测量结果。