C++ C++；11异步及；未来输出无序

我曾试图通过sleep\u模拟C++11处理来自其他服务的延迟响应的随机时间

// g++ f1.cpp -o f1 -std=c++11 -lpthread
#include <future>
#include <iostream>
#include <vector>
#include <chrono>
#include <thread>
#include <random>
#include <fstream>

using namespace std;

ofstream fout("log.txt");

int twice(int m) {
    random_device rd;
    int isleept = rd() % 100 + 1;
    this_thread::sleep_for(chrono::milliseconds(isleept));
    fout << m << " done with " << isleept << " milliseconds" << endl;
    return 2 * m;
}

int main() {
    vector<future<int> > futs;

    for (int i=0; i<10; i++) {
        futs.push_back(async(twice, i));
    }

    for (auto &e : futs) {
        e.get();
    }

    return 0;
}

---

我想知道如何改进我的程序？

这个程序会导致数据竞争。即，从多个线程同时调用

fout

，而无需适当的锁定

我建议增加一些锁定机制。例如，您可以添加一个

std:：mutex

，并在该

std:：mutex

之上使用

std:：lock\u guard

将输出锁定到日志文件：

std::mutex io_mutex;

int twice(int m) {
    random_device rd;
    int isleept = rd() % 100 + 1;
    this_thread::sleep_for(chrono::milliseconds(isleept));

    std::lock_guard<std::mutex> lock(io_mutex);
    fout << m << " done with " << isleept << " milliseconds" << endl;

    return 2 * m;
}

std:：mutex io_mutex；
整数倍（整数米）{
随机器件rd；
int isleep=rd（）%100+1；
此线程：：sleep（时钟：：毫秒（isleep））；
std：：锁和保护锁（io和互斥）；
fout此程序导致数据争用。即，
fout
是从多个线程同时调用的，没有适当的锁定

我建议添加一些锁定机制。例如，您可以添加一个
std:：mutex
，并在该
std:：mutex
之上使用
std:：lock\u guard
将输出锁定到日志文件：

std::mutex io_mutex;

int twice(int m) {
    random_device rd;
    int isleept = rd() % 100 + 1;
    this_thread::sleep_for(chrono::milliseconds(isleept));

    std::lock_guard<std::mutex> lock(io_mutex);
    fout << m << " done with " << isleept << " milliseconds" << endl;

    return 2 * m;
}

std:：mutex io_mutex；
整数倍（整数米）{
随机器件rd；
int isleep=rd（）%100+1；
此线程：：sleep（时钟：：毫秒（isleep））；
std：：锁和保护锁（io和互斥）；
这不是这里的主要问题，但您应该使用随机引擎（如mt1997）和
std:：uniform_int_分布
，而不是对随机设备的输出应用模。这不是这里的主要问题，但您应该使用随机引擎（如mt1997）和
std:：uniform_int_distribution
，不将模应用于随机设备的输出。