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)

编辑：

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

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

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

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

Answer 2

我认为互斥（单独）不适合这项工作。您可能想要考虑使用信号量（或类似的东西）。你描述的内容听起来很像producer/consumer problem，即每当另一个进程完成任务时，允许一个进程运行一次。因此，您可能还要了解生产者/消费者模式。例如，这个系列可能会给你一些想法：

A multi-threaded Producer Consumer with C++11

std::mutex与std::condition_variable结合以模仿信号量的行为。一种看似合理的方法。您可能不会计数和减少，而是使用需要重绘语义来切换true和false变量。

供参考：

Answer 3

这是因为您使用单独的drawing变量，该变量仅在呈现线程在wait之后重新获取互斥锁时设置，这可能为时已晚。删除drawing变量并且更新线程中的wait检查替换为! m_rt.readyToDraw（已由更新线程设置，因此不易受逻辑影响）时，问题消失比赛。

Modified code and results

那就是说，由于线程不能并行工作，我真的没有意识到有两个线程。除非你以后选择实施双重（甚至三重）缓冲。

Answer 4

计算机图形中经常使用的技术是使用双缓冲区。不是让渲染器和生产者对内存中的相同数据进行操作，而是每个都有自己的缓冲区。这是通过使用两个独立的缓冲区实现的，并在需要时切换它们。生产者更新一个缓冲区，当它完成后，它会切换缓冲区并用下一个数据填充第二个缓冲区。现在，当生产者正在处理第二个缓冲区时，渲染器与第一个缓冲区一起工作并显示它。

您可以通过让渲染器锁定交换操作来使用此技术，以便生产者可能必须等到渲染完成。

同步非常快的线程

4 个答案: