C++ std::thread - 多线程比单线程慢？

Question

我正在参加 Advent of Code 2021。在第 6 天有这个难题

在提供适当、快速的解决方案之前，我做了递归 function ，如下所示：

long long unsigned int getOffspring(int daysToEnd){
    static long long unsigned int i = 0;
    while(daysToEnd > 0){
        getOffspring(daysToEnd - 9);
        daysToEnd -= 7;
    }
    i+=1;
    return i;
}

输入中的 300 个条目中的每一个都在循环中调用它。 对于谜题的第二部分（256 天而不是 80 天），它给了我一个正确的答案，但计算需要 100 分钟（每次循环迭代大约 300 * 20 s）。

然后我决定摆弄线程，因为我对它们没有太多经验。

我的想法是通过std::thread::hardware_concurrency()创建尽可能多的线程，在我的情况下它是 12 个线程。 我认为拥有 12 个线程会加快总操作速度。 10倍。

但是当我开始测量执行时间时，应用程序变得更慢而不是更快。

我编写的代码（现在它有一些宏可以更轻松地操作数据收集）：

#include <iostream>
#include <fstream>
#include <vector>
#include <list>
#include <thread>
#include <mutex>
#include <atomic>
#include <chrono>

std::atomic<int> threadsLeft (0);
std::mutex myMtx;
std::mutex totalMtx;
constexpr auto HARDWARE_THREADS = 12;

// std::atomic<long long unsigned int > totalCounter(0); // UNUSED FOR NOW
volatile long long unsigned int totalCounter = 0;
volatile long long unsigned int offsprings[HARDWARE_THREADS] = {0,0,0,0,0,0,0,0,0,0,0,0}; //TOTAL COUNTER FOR EACH THREAD (SUPPOSE IT'S UP TO 12)
volatile int fish = 0; 


// MODIFY THESE DEFINES FOR TESTS
#define DAYS 160 //SET TO DAY VALUE

// #define USE_TABLE //SET OR COMMENT FOR DIFFERENT COUNTING
#define USE_MAX_THREADS // SET OR COMMENT FOR DIFFERENT COUNTING
// #define DO_NOT_USE_THREADS // SET OR COMMENT FOR NOT SPAWNING THREAD

void getOffspring(int daysToEnd, const int& threadID = 0){
    
    while(daysToEnd > 0){
        getOffspring(daysToEnd - 9, threadID);
        daysToEnd -= 7;
    }

    #ifdef USE_TABLE
        //AVOID MUTEX
        offsprings[threadID] +=1;
    #else
        totalMtx.lock();
        totalCounter += 1;
        totalMtx.unlock();
    #endif
 }
    
void threadJob(std::list<int> * inputValues, int threadID){
    
    while(1){
        myMtx.lock();
        if (inputValues->size() <= 0){
            myMtx.unlock();
            break;
        }
        int startCntr = inputValues->back();
        inputValues->pop_back();
        myMtx.unlock();
        auto start = std::chrono::steady_clock::now();
        getOffspring( DAYS - startCntr, threadID); //Switch between 
        myMtx.lock();
        std::cout << "Done in "<< std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start).count()  << " fish " << fish++ << std::endl;
        myMtx.unlock();
    }
}


int main(){
    auto origin = std::chrono::steady_clock::now();
    std::string fileName("in6.txt");
    std::fstream file;
    std::string number;
    std::list<int> inputValues;
    std::vector<std::thread> threads;

    file.open(fileName);
    while(!file.eof()){
        std::getline(file,number,',');
        inputValues.push_back(std::stoi(number));
    }

    #ifdef USE_MAX_THREADS
        threadsLeft = std::thread::hardware_concurrency() ;
    #else
        threadsLeft = 1;
    #endif 


    #ifdef DO_NOT_USE_THREADS
        for (auto x : inputValues){
            auto start = std::chrono::steady_clock::now();
            getOffspring(DAYS - x,0);
            std::cout << "Done in "<< std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - start).count()  << " fish " << fish++ << std::endl;
        }
    #else
        for( int i = 0 ; i < threadsLeft ; ++i){
            threads.emplace_back(std::thread(threadJob,&inputValues,i));        
        }
        for (std::thread & t : threads) {
            t.join();
        }
    #endif

    for(auto x  = 0 ; x < HARDWARE_THREADS ;  ++x ){
        totalCounter += offsprings[x];
    }
    std::cout << "Total value: " << totalCounter << std::endl;
    std::cout << "TotalTime ;"<< std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - origin).count() << "; us " << std::endl;
}

经过 80 天（30 次测量）和 160 天（10 次测量）的一些测量后，我得到了以下总执行时间的结果：

最佳总时间：

1. 4643.2 us 80 天，在表中计数，最大线程数
2. 5539.5 us 80 天，在表中计数，单线程
3. 5703.8 us 80 天，在表中计数，不要产生线程

最佳总时间：

1. 1677962.7 us 160 天，在表中计数，最大线程数
2. 2201221.2 我们 160 天，在表中计数，不要产生线程
3. 2454063.0 us 160 天，在表中计数，单线程

最差的总时间：

1. 32238021.0 us 160 天，使用互斥锁计数，最大线程数
2. 8444803.9 我们 160 天，使用互斥锁计数，单线程
3. 8329748.3 我们 160 天，在 MUTEX 中计数，不要产生线程

如果我理解正确，互斥体有巨大的开销，因此代码执行需要更长的时间。 我对吗？ 最后是我最重要的问题：

为什么使用更多的线程可以将这个代码加速大约 25%？ 因为我在这个多线程的东西上是菜鸟，所以我对任何输入都会非常感激！

此致！