std::thread to std::async делает ОГРОМНОЕ повышение производительности. Как это может быть возможно?

Question

Я сделал тестовый код между std:: thread и std::async.

#include <iostream>
#include <mutex>
#include <fstream>
#include <string>
#include <memory>
#include <thread>
#include <future>
#include <functional>
#include <boost/noncopyable.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/filesystem.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/asio.hpp>

namespace fs = boost::filesystem;
namespace pt = boost::posix_time;
namespace as = boost::asio;
class Log : private boost::noncopyable
{
public:
    void LogPath(const fs::path& filePath) {
        boost::system::error_code ec;
        if(fs::exists(filePath, ec)) {
            fs::remove(filePath);
        }
        this->ofStreamPtr_.reset(new fs::ofstream(filePath));
    };

    void WriteLog(std::size_t i) {
        assert(*this->ofStreamPtr_);
        std::lock_guard<std::mutex> lock(this->logMutex_);
        *this->ofStreamPtr_ << "Hello, World! " << i << "\n";
    };

private:
    std::mutex logMutex_;
    std::unique_ptr<fs::ofstream> ofStreamPtr_;
};

int main(int argc, char *argv[]) {
    if(argc != 2) {
        std::cout << "Wrong argument" << std::endl;
        exit(1);
    }
    std::size_t iter_count = boost::lexical_cast<std::size_t>(argv[1]);

    Log log;
    log.LogPath("log.txt");

    std::function<void(std::size_t)> func = std::bind(&Log::WriteLog, &log, std::placeholders::_1);

    auto start_time = pt::microsec_clock::local_time();
    ////// Version 1: use std::thread //////
//    {
//        std::vector<std::shared_ptr<std::thread> > threadList;
//        threadList.reserve(iter_count);
//        for(std::size_t i = 0; i < iter_count; i++) {
//            threadList.push_back(
//                std::make_shared<std::thread>(func, i));
//        }
//
//        for(auto it: threadList) {
//            it->join();
//        }
//    }

//    pt::time_duration duration = pt::microsec_clock::local_time() - start_time;
//    std::cout << "Version 1: " << duration << std::endl;

    ////// Version 2: use std::async //////
    start_time = pt::microsec_clock::local_time();
    {
        for(std::size_t i = 0; i < iter_count; i++) {
            auto result = std::async(func, i);
        }
    }

    duration = pt::microsec_clock::local_time() - start_time;
    std::cout << "Version 2: " << duration << std::endl;

    ////// Version 3: use boost::asio::io_service //////
//    start_time = pt::microsec_clock::local_time();
//    {
//        as::io_service ioService;
//        as::io_service::strand strand{ioService};
//        {
//            for(std::size_t i = 0; i < iter_count; i++) {
//                strand.post(std::bind(func, i));
//            }
//        }
//        ioService.run();
//    }

//    duration = pt::microsec_clock::local_time() - start_time;
//    std::cout << "Version 3: " << duration << std::endl;


}

С 4-ядерным процессором CentOS 7 (gcc 4.8.5) версия 1(использующая std::thread) примерно в 100 раз медленнее по сравнению с другими реализациями.

Итерация Версия1 Версия2 Версия3
100       0,0034 с 0,000051 с 0,000066 с
1000      0.038s     0.00029s   0.00058s
10000     0,41 с 0,0042 с 0,0059 с
100000 бросков 0.026с 0.061с

Почему резьбовая версия такая медленная? Я думал, что каждая тема не займет много времени, чтобы завершить Log::WriteLog функция.

Answer 1

Функция никогда не может быть вызвана. Вы не передаете std::launch политики в версии 2, поэтому вы полагаетесь на поведение по умолчанию std::async (выделение мое):

Ведет себя так же, как async(std::launch::async | std::launch::deferred, f, args...), Другими словами, f может выполняться в другом потоке или может выполняться синхронно, когда std::future запрашивается для значения.

Попробуйте повторить тест с этим небольшим изменением:

auto result = std::async(std::launch::async, func, i);

Или вы можете позвонить result.wait() на каждой std::future во втором цикле, аналогично тому, как вы называете join() на всех потоках в версии 1. Это заставляет оценку std::future,

Обратите внимание, что с этим тестом существует серьезная, не связанная с этим проблема. func немедленно получает блокировку на всю продолжительность вызова функции, что делает невозможным параллелизм. Использование потоков здесь не дает никаких преимуществ - я подозреваю, что это будет значительно медленнее (из-за создания потоков и накладных расходов на блокировку), чем последовательная реализация.