c++ - 同步非常快的线程

Question

在下面的例子(一个理想化的“游戏”)中有两个线程。更新数据的主线程和将数据“呈现”到屏幕的 RenderThread。我需要这两个同步。如果不为其中的每一个运行渲染，我无法承受运行多个更新迭代。

我使用 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;
}

Here is the source of this small example code ，正如您在 ideone 的运行中看到的那样，输出为 frame 0: 19(这意味着渲染线程已完成单次迭代，而更新线程已完成其全部 20 次迭代)。

如果我们取消对第 75 行的注释(即为更新循环模拟一些时间)一切都会运行良好。每个更新迭代都有关联的渲染迭代。

有没有一种方法可以真正真正地同步这些线程，即使其中一个线程仅在几纳秒内完成一次迭代，而且如果它们都需要一些合理的毫秒数来完成，也不会造成性能损失？

Answer 1

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

你需要 2 把锁:

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

更新者:

wait (renderingLk)
update
signal(updaterLk)

渲染器:

wait (updaterLk)
render
signal(renderingLk)

编辑:

即使看起来简单，也有几个问题需要解决:

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

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

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