问多线程从单线程循环中慢于预期。

EN

#include <iostream>
#include <thread>
#include <chrono>
#include <string>
#include <vector>

#define CALC_NUMBER 10000000000ull

struct Counters {
    unsigned long long int CountDivTen = 0;
    unsigned long long int CountDivEight = 0;
    unsigned long long int CountDivFive = 0;
    unsigned long long int CountEven = 0;
};

Counters DivCounter;

// For multi-threading
std::vector<std::pair<unsigned long long, unsigned long long>> parts = {
    {1, 2500000000}, {2500000001, 5000000000}, {5000000001, 7500000000},    
    {7500000001, 10000000000}
};

// Multi-threading counters.
std::vector<Counters> MyCounters(4);


void SingleThreaded()
{
    std::chrono::high_resolution_clock::time_point StartTime = 
                         std::chrono::high_resolution_clock::now();

    for (unsigned long long x = 1; x <= CALC_NUMBER; ++x)
    {
        // Count the even number
        if ((x % 2) == 0)
            ++DivCounter.CountEven;

        // Count divisible by 5
        if ((x % 5) == 0)
            ++DivCounter.CountDivFive;

        // Count divisible by 8
        if ((x % 8) == 0)
            ++DivCounter.CountDivEight;

        // Count divisible by 10
        if ((x % 10) == 0)
            ++DivCounter.CountDivTen;
    }

    auto elapsed = std::chrono::high_resolution_clock::now() - StartTime;
    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(elapsed).count();
    std::cout << "Time in seconds: " << seconds << std::endl;
}

void MultiThread_Merge(int index)
{
    for (unsigned long long x = parts[index].first; x <= parts[index].second; ++x)
    {
        // Count the even number
        if ((x % 2) == 0)
            ++MyCounters[index].CountEven;

        // Count divisible by 5
        if ((x % 5) == 0)
            ++MyCounters[index].CountDivFive;

        // Count divisible by 8
        if ((x % 8) == 0)
            ++MyCounters[index].CountDivEight;

        // Count divisible by 10
        if ((x % 10) == 0)
            ++MyCounters[index].CountDivTen;
    }
}

void DoThreadUsingMerge()
{
    // Start timer
    std::chrono::high_resolution_clock::time_point StartTime = 
                     std::chrono::high_resolution_clock::now();

    // Create four Threads
    std::vector<std::thread> MyThreads(4);

    // Create Threads
    for (size_t i = 0; i < MyThreads.size(); ++i) {

        MyThreads[i] = std::thread(MultiThread_Merge, i);
    }

    // Wait for all threads to finish.
    for (size_t i = 0; i < MyThreads.size(); ++i) {

        MyThreads[i].join();
    }

    // When threads are done, add up numbers.
    for (auto i : MyCounters)
    {
        // Add all the numbers.
        DivCounter.CountEven += i.CountEven;
        DivCounter.CountDivFive += i.CountDivFive;
        DivCounter.CountDivEight += i.CountDivEight;
        DivCounter.CountDivTen += i.CountDivTen;
    }

    // Stop timer and get time.
    auto elapsed = std::chrono::high_resolution_clock::now() - StartTime;
    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(elapsed).count();
    std::cout << "Time in seconds: " << seconds << std::endl;
}

void DisplayCounters()
{
    std::cout << "Count divisible by 2: " << DivCounter.CountEven << std::endl;
    std::cout << "Count divisible by 5: " << DivCounter.CountDivFive << std::endl;
    std::cout << "Count divisible by 8: " << DivCounter.CountDivEight << std::endl;
    std::cout << "Count divisible by 10: " << DivCounter.CountDivTen << std::endl;
}


int main()
{
    std::cout << "Calculation number: " << CALC_NUMBER << std::endl;

    std::cout << "\n============================================\n";
    std::cout << "\nSingle-Threaded ..\n";

    SingleThreaded();

    DisplayCounters();

    // Reset for multi-thread
    DivCounter.CountEven = 0;
    DivCounter.CountDivFive = 0;
    DivCounter.CountDivEight = 0;
    DivCounter.CountDivTen = 0;

    std::cout << "\n============================================\n";
    std::cout << "\nMulti-Threaded (Merge) ..\n";

    DoThreadUsingMerge();
    DisplayCounters();

    system("pause");
}