Question

我正在尝试编写一个使用c ++ 11线程功能的程序来生成多个线程，主线程必须等待每个生成的线程完成，并且所有生成的线程必须并行运行。我想出了以下方法：

#include <iostream>
#include <stdio.h>
#include <thread>
#include <condition_variable>
#include <mutex>

using namespace std;

class Producer
{
public:
    Producer(int a_id):
        m_id(a_id),
        m_running(false),
        m_ready(false),
        m_terminate(false)
    {
        m_id = a_id;
        m_thread = thread(&Producer::run, this);
        while (!m_ready) {}
    }

    ~Producer() {
        terminate();
        m_thread.join();
    }

    void wait() {
        unique_lock<mutex> lock(m_waitForRunFinishMutex);
        m_cond.wait(lock);
        // avoid spurious wake up
        if (m_running) {
            wait();
        }
        lock.unlock();
        cout << "wait exit " << m_id << endl;
    }

    void start() {
        m_running = true;
        m_cond.notify_all();
    }

    void terminate() {
        start();
        m_terminate = true;
    }

    void run() {
        m_ready = true;
        do {
            unique_lock<mutex> lock(m_mutex);
            while (!m_running) {
                m_cond.wait(lock);
            }

            if (!m_terminate) {
                cout << "running thread: " << m_id << endl;
            }

            m_running = false;
            m_cond.notify_all();
        } while (!m_terminate);
    }

private:
    int m_id;
    bool m_running;
    bool m_ready;
    bool m_terminate;
    thread m_thread;
    mutex m_mutex;
    mutex m_waitForRunFinishMutex;
    condition_variable m_cond;
};

只用一个线程进行测试时，程序运行正常，即以下程序：

int main()
{
    Producer producer1(1);    
    producer1.start();
    producer1.wait();

    return 0;
}

结果如下：

running thread: 1
wait exit: 1

但是，如果我用2个线程测试程序，例如：

int main()
{
    Producer producer1(1);
    Producer producer2(2);

    producer1.start();
    producer2.start();

    producer1.wait();
    producer2.wait();

    return 0;
}

我得到以下输出：

running thread: 2
running thread: 1
wait exit 1

似乎producer2从未得到通知（在producer2.wait()中），因此程序永远不会完成。希望有人可以指出我在这里缺少的东西。

感谢大家帮助解决问题。最终，问题的根本原因在接受的答案的第（3）点中描述。我通过更正wait函数解决了这个问题，如下所示：

void wait() {
    unique_lock<mutex> lock(m_waitForRunFinishMutex);
    while (m_running) {
        m_cond.wait(lock);
    }
    lock.unlock();
}

Answer 1

以下是一目了然的快速问题集。

wait（）是递归的，没有解锁其独特的锁（根据Detonar的评论）
while (!m_ready) {}不在内存屏障中（尝试使用某些优化进行编译，看看会发生什么！）
如果在调用wait（）之前工作线程完成;在等待条件变量之前没有执行检查。由于工作线程完整;它永远不会被唤醒。显然，在等待条件变量之前，您必须检查线程是否可以在互斥锁中被唤醒。

如何等待多个线程完成（使用c ++ 11线程）？

1 个答案: