同步非常快的线程

Question

在下面的例子中(理想化的"游戏")有两个线程.更新数据并将RenderThread其"呈现"到屏幕的主线程.我需要的是那两个要同步的东西.我没有能力运行几次更新迭代而不为它们中的每一个运行渲染.

我使用a condition_variable来同步这两个,所以理想情况下,更快的线程将花费一些时间等待更慢.但是,如果其中一个线程在很短的时间内完成迭代,则条件变量似乎不起作用.它似乎很快就会重新获取互斥锁的锁定,然后wait另一个线程才能获取它.即使notify_one被称为

#include <iostream>
#include <thread>
#include <chrono>
#include <atomic>
#include <functional>
#include <mutex>
#include <condition_variable>

using namespace std;

bool isMultiThreaded = true;

struct RenderThread
{
    RenderThread()
    {
        end = false;
        drawing = false;
        readyToDraw = false;
    }

    void Run()
    {
        while (!end)
        {
            DoJob();
        }
    }

    void DoJob()
    {
        unique_lock<mutex> lk(renderReadyMutex);
        renderReady.wait(lk, [this](){ return readyToDraw; });
        drawing = true;

        // RENDER DATA
        this_thread::sleep_for(chrono::milliseconds(15)); // simulated render time
        cout << "frame " << count << ": " << frame << endl;
        ++count;

        drawing = false;
        readyToDraw = false;

        lk.unlock();
        renderReady.notify_one();
    }

    atomic<bool> end;

    mutex renderReadyMutex;
    condition_variable renderReady;
    //mutex frame_mutex;
    int frame = -10;
    int count = 0;

    bool readyToDraw;
    bool drawing;
};

struct UpdateThread
{
    UpdateThread(RenderThread& rt)
        : m_rt(rt)
    {}

    void Run()
    {
        this_thread::sleep_for(chrono::milliseconds(500));

        for (int i = 0; i < 20; ++i)
        {
            // DO GAME UPDATE

            // when this is uncommented everything is fine
            // this_thread::sleep_for(chrono::milliseconds(10)); // simulated update time

            // PREPARE RENDER THREAD
            unique_lock<mutex> lk(m_rt.renderReadyMutex);
            m_rt.renderReady.wait(lk, [this](){ return !m_rt.drawing; });

            m_rt.readyToDraw = true;

            // SUPPLY RENDER THREAD WITH DATA TO RENDER
            m_rt.frame = i;

            lk.unlock();
            m_rt.renderReady.notify_one();

            if (!isMultiThreaded)
                m_rt.DoJob();
        }        

        m_rt.end = true;
    }

    RenderThread& m_rt;
};

int main()
{
    auto start = chrono::high_resolution_clock::now();

    RenderThread rt;
    UpdateThread u(rt);

    thread* rendering = nullptr;
    if (isMultiThreaded)
        rendering = new thread(bind(&RenderThread::Run, &rt));

    u.Run();

    if (rendering)
        rendering->join();

    auto duration = chrono::high_resolution_clock::now() - start;
    cout << "Duration: " << double(chrono::duration_cast<chrono::microseconds>(duration).count())/1000 << endl;


    return 0;
}

下面是这个小示例代码的来源,正如您在ideone的运行中所看到的那样,输出是frame 0: 19(这意味着渲染线程已经完成了一次迭代,而更新线程已经完成了所有20次).

如果我们取消注释第75行(即模拟更新循环的一些时间),一切运行正常.每次更新迭代都有一个关联的渲染迭代.

有没有办法真正真正同步​​这些线程,即使其中一个线程仅在几纳秒内完成迭代,但如果它们都花费一些合理的毫秒数来完成,也没有性能损失？

Answer 1

如果我理解正确，则您希望2个线程交替工作：updater等待直到渲染器完成，然后再次进行迭代，渲染器等待直到更新器完成，然后再次进行迭代。计算的一部分可以是并行的，但是两者之间的迭代次数应相似。

您需要2个锁：

• 一个用于更新
• 一个用于渲染

更新器：

wait (renderingLk)
update
signal(updaterLk)

渲染器：

wait (updaterLk)
render
signal(renderingLk)

编辑：

即使看起来很简单，也要解决几个问题：

允许部分计算并行进行：如上面的代码片段所示，更新和渲染将不是并行的而是顺序的，因此拥有多线程没有任何好处。对于真正的解决方案，应该在等待之前进行一些计算，并且只有新值的副本才需要在等待和信号之间。渲染相同：所有渲染都需要在信号之后进行，并且仅在等待和信号之间获取值。

该实现还需要关心初始状态：因此在第一次更新之前不执行任何渲染。

两个线程的终止：因此，在另一个终止之后，没有人会保持锁定或无限循环。