使用线程时出现意外输出

Question

我正在为一款游戏开发概念验证测试程序，其中某些动作是线程化的，并且信息输出到每个线程的命令 window。到目前为止，我已经得到了基本的线程处理过程，但似乎我调用的函数中的计算并没有为每个线程编写，而是每个线程都在覆盖其他输出。

期望或预期的输出是每个线程将输出在 mLaser 的 mCycle 函数中计算的信息。从本质上讲，这意味着每个对象都有一个计时器，用于倒计时直到该对象完成其任务。每个线程都应该有一个输出，所以如果有五个线程正在运行，则应该有五个独立倒计时的计数器。

当前输出是这样的，每个线程都在同一个 space 中输出自己的信息，然后覆盖另一个线程试图输出的信息。

这是程序当前输出的示例：

Time until cycle Time until cycle 74 is complete: 36 is complete:

92 seconds 2 seconds ress any key to continue . . .

如果您检查信息是如何从 mCycle 中计算出来的，您可以看到数字和其他文本出现在它们不应该出现的地方的偏差。

应该显示的是这些行比较长：

Time until cycle 1 is complete:

92 seconds

Time until cycle 2 is complete:

112 seconds

Time until cycle 3 is complete:

34 seconds

Cycle 4 has completed!

我不确定这是否是由于我的代码结构导致某种线程锁定，或者只是我对输出编码的疏忽。如果我能得到一双新的眼睛来检查代码并指出任何可能是错误的地方，我将不胜感激。

这是我的代码，它应该可以在任何 MSVS 2013 安装中编译（未使用自定义库）

#include <iostream>
#include <Windows.h>
#include <string>
#include <vector>
#include <random>
#include <thread>
#include <future>

using namespace std;

class mLaser
{
public:
    mLaser(int clen, float mamt)
    {
        mlCLen = clen;
        mlMAmt = mamt;
    }

    int getCLen()
    {
        return mlCLen;
    }

    float getMAmt()
    {
        return mlMAmt;
    }

    void mCycle(int i1, int mCLength)
    {
        bool bMCycle = true;

        int mCTime_left = mCLength * 1000;
        int mCTime_start = GetTickCount(); //Get cycle start time
        int mCTime_old = ((mCTime_start + 500) / 1000);

        cout << "Time until cycle " << i1 << " is complete: " << endl;

        while (bMCycle)
        {
            cout << ((mCTime_left + 500) / 1000) << " seconds";

            bool bNChange = true;

            while (bNChange)
            {
                //cout << ".";

                int mCTime_new = GetTickCount();

                if (mCTime_old != ((mCTime_new + 500) / 1000))
                {
                    //cout << mCTime_old << " " << ((mCTime_new+500)/1000) << endl;
                    mCTime_old = ((mCTime_new + 500) / 1000);
                    mCTime_left -= 1000;
                    bNChange = false;
                }
            }
            cout << " \r" << flush;
            if (mCTime_left == 0)
            {
                bMCycle = false;
            }
        }

        cout << "Mining Cycle " << i1 << " finished" << endl;
        system("Pause");

        return true;
    }


    private:
    int mlCLen;
    float mlMAmt;
};

string sMCycle(mLaser ml, int i1, thread& thread);

int main()
{
    vector<mLaser> mlasers;
    vector<thread> mthreads;
    future<string> futr;

    random_device rd;
    mt19937 gen(rd());

    uniform_int_distribution<> laser(1, 3);
    uniform_int_distribution<> cLRand(30, 90);
    uniform_real_distribution<float> mARand(34.0f, 154.3f);

    int lasers;
    int cycle_time;
    float mining_amount;

    lasers = laser(gen);

    for (int i = 0; i < lasers-1; i++)
    {    
        mlasers.push_back(mLaser(cLRand(gen), mARand(gen)));
        mthreads.push_back(thread());
    }

    for (int i = 0; i < mlasers.size(); i++)
    {
        futr = async(launch::async, [mlasers, i, &mthreads]{return sMCycle(mlasers.at(i), i + 1, mthreads.at(i)); });
       
        //mthreads.at(i) = thread(bind(&mLaser::mCycle, ref(mlasers.at(i)), mlasers.at(i).getCLen(), mlasers.at(i).getMAmt()));
    }

    for (int i = 0; i < mthreads.size(); i++)
    {
        //mthreads.at(i).join();
    }


    //string temp = futr.get();
    //float out = strtof(temp.c_str(),NULL);

    //cout << out << endl; 

    system("Pause");
    return 0;
}

string sMCycle(mLaser ml, int i1, thread& t1)
{
    t1 = thread(bind(&mLaser::mCycle, ref(ml), ml.getCLen(), ml.getMAmt()));
    //t1.join();

    return "122.0";
}

Answer 1

虽然从多个线程并发写入 std::cout 必须没有数据竞争，但不能保证并发写入不会交错。我不确定一个线程的一个写操作是否可以与另一个线程的一个写操作交错，但它们肯定可以在写操作之间交错（我认为来自不同线程的单个输出可以交错）。

标准关于并发访问标准流对象（即 std::cout、std::cin 等）的内容在 27.4.1 [iostream.objects.overview] 第 4 段:

Concurrent access to a synchronized (27.5.3.4) standard iostream object’s formatted and unformatted input (27.7.2.1) and output (27.7.3.1) functions or a standard C stream by multiple threads shall not result in a data race (1.10). [ Note: Users must still synchronize concurrent use of these objects and streams by multiple threads if they wish to avoid interleaved characters. —end note ]

如果您想让输出出现在某种单元中，您将需要同步对 std::cout 的访问，例如，通过使用互斥锁。

Answer 2

虽然 Dietmar 的回答已经足够了，但我还是决定走一条不同的、更简单的路线。由于我正在创建 class 的实例并且我正在线程中访问这些实例，因此我选择在线程处理期间更新那些 class' 数据，然后在线程完成执行后调用更新的数据。

这样我就不必处理恼人的问题，例如数据竞争，也不必在 shared_future 的向量中从异步获取输出。这是我修改后的代码，以防其他人想要实现类似的东西：

#include <iostream>
#include <Windows.h>
#include <string>
#include <vector>
#include <random>
#include <thread>
#include <future>

using namespace std; //Tacky, but good enough fo a poc D:

class mLaser
{
public:
    mLaser(int clen, float mamt, int time_left)
    {
        mlCLen = clen;
        mlMAmt = mamt;
        mCTime_left = time_left;
        bIsCompleted = false;
    }

    int getCLen()
    {
        return mlCLen;
    }

    float getMAmt()
    {
        return mlMAmt;
    }

    void setMCOld(int old)
    {
        mCTime_old = old;
    }

    void mCycle()
    {
        if (!bIsCompleted)
        {
            int mCTime_new = GetTickCount(); //Get current tick count for comparison to mCOld_time

            if (mCTime_old != ((mCTime_new + 500) / 1000)) //Do calculations to see if time has passed since mCTime_old was set
            {
                //If it has then update mCTime_old and remove one second from mCTime_left.
                mCTime_old = ((mCTime_new + 500) / 1000);
                mCTime_left -= 1000;
            }

            cur_time = mCTime_left;
        }

        else
        {
            mCTime_left = 0;
        }
    }

    int getCTime()
    {
        return cur_time;
    }

    int getCTLeft()
    {
        return mCTime_left;
    }

    void mCComp()
    {
        bIsCompleted = true;
    }

    bool getCompleted()
    {
        return bIsCompleted;
    }

private:
    int mlCLen; //Time of a complete mining cycle
    float mlMAmt; //Amoung of ore produced by one mining cycle (not used yet)
    int cur_time; //The current time remaining in the current mining cycle; will be removing this as it is just a copy of mCTime_left that I was going to use for another possiblity to make this code work
    int mCTime_left; //The current time remaining in the current mining cycle
    int mCTime_old; //The last time that mCycle was called

    bool bIsCompleted; //Flag to check if a mining cycle has already been accounted for as completed
};

void sMCycle(mLaser& ml, int i1, thread& _thread); //Start a mining cycle thread

//Some global defines
random_device rd;
mt19937 gen(rd());

uniform_int_distribution<> laser(1, 10); //A random range for the number of mlaser entities to use
uniform_int_distribution<> cLRand(30, 90); //A random time range in seconds of mining cycle lengths
uniform_real_distribution<float> mARand(34.0f, 154.3f); //A random float range of the amount of ore produced by one mining cycle (not used yet)

int main()
{
    //Init some variables for later use
    vector<mLaser> mlasers; //Vector to hold mlaser objects
    vector<thread> mthreads; //Vector to hold threads
    vector<shared_future<int>> futr; //Vector to hold shared_futures (not used yet, might not be used if I can get the code working like this)

    int lasers; //Number of lasers to create
    int cycle_time; //Mining cycle time
    int active_miners = 0; //Number of active mining cycle threads (one for each laser)
    float mining_amount; //Amount of ore produced by one mining cycle (not used yet)

    lasers = laser(gen); //Get a random number
    active_miners = lasers; //Set this to that random number for the while loop later on

    //Create the mlaser objects and push them into the mlasers vector
    for (int i = 0; i < lasers; i++)
    {
        int clength = cLRand(gen);

        mlasers.push_back(mLaser(clength, mARand(gen), (clength * 1000)));

        //Also push thread obects into mthreads for each laser object
        mthreads.push_back(thread());
    }

    //Setup data for mining cycles
    for (int i = 0; i < mlasers.size(); i++)
    {
        int mCTime_start = GetTickCount(); //Get cycle start time
        mlasers.at(i).setMCOld(((mCTime_start + 500) / 1000));
    }

    //Print initial display for mining cycles
    for (int i = 0; i < mlasers.size(); i++)
    {
        cout << "Mining Laser " << i + 1 << " cycle will complete in " << (mlasers.at(i).getCTLeft() + 500) / 1000 << " seconds..." << endl;
    }

    while (active_miners > 0)
    {   
        for (int i = 0; i < mlasers.size(); i++)
        {
            //futr.push_back(async(launch::async, [mlasers, i, &mthreads]{return sMCycle(mlasers.at(i), i + 1, mthreads.at(i)); }));
            async(launch::async, [&mlasers, i, &mthreads]{return sMCycle(mlasers.at(i), i + 1, mthreads.at(i)); }); //Launch a thread for the current mlaser object
            //mthreads.at(i) = thread(bind(&mLaser::mCycle, ref(mlasers.at(i)), mlasers.at(i).getCLen(), mlasers.at(i).getMAmt()));
        }

        //Output information from loops
        //cout << " \r" << flush; //Return cursor to start of line and flush the buffer for the next info

        system("CLS");

        for (int i = 0; i < mlasers.size(); i++)
        {
            if (mlasers.at(i).getCTLeft() != 0) //If mining cycle is not completed
            {
                cout << "Mining Laser " << i + 1 << " cycle will complete in " << (mlasers.at(i).getCTLeft() + 500) / 1000 << " seconds..." << endl;
            }

            else if (mlasers.at(i).getCTLeft() == 0) //If it is completed
            {
                if (!mlasers.at(i).getCompleted())
                {
                    mlasers.at(i).mCComp();
                    active_miners -= 1;
                }

                cout << "Mining Laser " << i + 1 << " has completed its mining cycle!" << endl;
            }
        }
    }


    /*for (int i = 0; i < mthreads.size(); i++)
    {
        mthreads.at(i).join();
    }*/


    //string temp = futr.get();
    //float out = strtof(temp.c_str(),NULL);

    //cout << out << endl;

    system("Pause");
    return 0;
}

void sMCycle(mLaser& ml, int i1,thread& _thread)
{
    //Start thread
    _thread = thread(bind(&mLaser::mCycle, ref(ml)));

    //Join the thread
    _thread.join();
}

使用线程时出现意外输出

Unexpected Output While Using Threads

c++

multithreading

command-line-interface