同步非常快的线程答案

【问题标题】：Synchronizing very fast threads同步非常快的线程
【发布时间】：2016-01-05 19:32:34
【问题描述】：

在以下示例（理想化的“游戏”）中，有两个线程。更新数据的主线程和将数据“渲染”到屏幕的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 行（即为更新循环模拟一些时间）一切运行正常。每个更新迭代都有一个关联的渲染迭代。

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

【问题讨论】：

这看起来像是一个传统的生产者-消费者问题。请看vichargrave.com/multithreaded-work-queue-in-c

标签： c++ multithreading synchronization

【解决方案1】：

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

A multi-threaded Producer Consumer with C++11

std::mutex 与 std::condition_variable 组合以模拟信号量的行为。一种看起来相当合理的方法。您可能不会向上和向下计数，而是使用 needs redraw 语义切换 true 和 false 变量。

供参考：

【讨论】：

您永远不需要在正确同步的代码中使用yield()
@JonathanWakely 这可能是真的。我删除了笔记。

【解决方案2】：

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

你需要两把锁：

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

更新者：

wait (renderingLk)
update
signal(updaterLk)

渲染器：

wait (updaterLk)
render
signal(renderingLk)

已编辑：

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

允许部分计算并行进行：和上面的sn-p一样，update和render不会是并行的，而是顺序的，所以多线程是没有好处的。对于一个真正的解决方案，一些计算应该在等待之前进行，只有新值的副本需要在等待和信号之间。渲染也一样：所有的渲染都需要在信号之后进行，并且只获取等待和信号之间的值。

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

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

【讨论】：

确实...这确实是最好和最简单的解决方案。我真傻:) 对不起。我想我太分心了，更新线程如此之快，我没有想到那个基本的解决方案......
这个想法很简单，但实现起来并不多。我不知道你对这类问题有多熟悉，我将编辑解决方案做一些注意事项。
由于在我的示例中同步线程的代码是由互斥锁保护的，这实际上是一行的问题。 m_rt.drawing = true 在第 85 行。就是这样。

【解决方案3】：

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

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

【讨论】：

【解决方案4】：

这是因为您使用了单独的drawing 变量，该变量仅在渲染线程在wait 之后重新获取互斥锁时设置，这可能为时已晚。当drawing 变量被删除并且更新线程中对wait 的检查被替换为! m_rt.readyToDraw（它已经由更新线程设置，因此不会受到逻辑竞争的影响）时，问题就消失了。

Modified code and results

也就是说，由于线程不能并行工作，我并没有真正理解拥有两个线程的意义。除非您应该选择稍后实现双（甚至三）缓冲。

【讨论】：