同步非常快的线程

在下面的示例(理想化的"游戏"(中，有两个线程。更新数据的主线程，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;
}

这是这个小示例代码的源代码，正如你所看到的，即使在 ideone 的运行时，输出也是frame 0: 19的(这意味着渲染线程完成了一次迭代，而更新线程已经完成了所有 20 次迭代(。

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

有没有办法真正同步这些线程，即使其中一个线程在短短几纳秒内完成迭代，但如果它们都需要一些合理的毫秒才能完成，也不会对性能造成影响？