C++ 拥有C++；条件变量类工作？

为了更好地理解C++11中条件变量的内部行为，我尝试编写自己的（简单/原始）条件变量类。看起来是这样的：

#include <iostream>
#include <thread>
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <vector>
#include <memory>
using namespace std;

class condVar {
public:
    void wait(unique_lock<mutex> & ul) {
        stop_list_mutex.lock(); // synchronize with other wait/noify calls

        ul.unlock();

        // store mutex so we can unlock it afterwards
        shared_ptr<mutex> stopm(new mutex());
        stop_list.push_back(stopm);
        stopm->lock();

        stop_list_mutex.unlock();

        // Stop now ...
        stopm->lock();    
        ul.lock();
    }

    template<typename Predicate>
    void wait(unique_lock<mutex> & ul, Predicate p) {
        while (!p()) wait(ul);
    }

    void notify_one() {
        lock_guard<mutex> lg(stop_list_mutex);
        if (stop_list.size() > 0) {
            stop_list.front()->unlock();
            stop_list.erase(stop_list.begin());
        }
    }

    void notify_all() {
        lock_guard<mutex> lg(stop_list_mutex);
        while (stop_list.size() > 0) {
            stop_list.front()->unlock();
            stop_list.erase(stop_list.begin());
        }
    }

private:

    mutex stop_list_mutex;
    vector<shared_ptr<mutex>> stop_list;
};

#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
类condVar{
公众：
无效等待（唯一锁定和ul）{
stop_list_mutex.lock（）；//与其他wait/noify调用同步
ul.unlock（）；
//存储互斥锁，以便我们以后可以解锁它
共享的_ptrstopm（新互斥体（））；
停止列表。向后推（stopm）；
stopm->lock（）；
stop_list_mutex.unlock（）；
//现在停止。。。
stopm->lock（）；
ul.lock（）；
}
模板
无效等待（唯一锁定&ul，谓词p）{
而（！p（））等待（ul）；
}
作废通知单（）{
锁定保护lg（停止列表互斥）；
如果（停止列表.size（）>0）{
停止列表。前（）->解锁（）；
停止列表。擦除（停止列表。开始（））；
}
}
void notify_all（）{
锁定保护lg（停止列表互斥）；
while（stop_list.size（）>0）{
停止列表。前（）->解锁（）；
停止列表。擦除（停止列表。开始（））；
}
}
私人：
互斥停止\列表\互斥；
向量停止列表；
};

---

一些简单的测试表明，与“real”C++11条件变量相比，行为没有任何差异。上述实现在理论上是否可行（除了我遗漏了许多错误检查代码，如前置条件和后置条件）？

您最好在

wait（）

函数中问这样的问题，我看不太合适。如果在解锁

ul

后但在锁定

stop\u mutex

前有人调用

notify

，通知将丢失。只需编辑问题，使

stop\u mutex

在等待（）开始时就被锁定（）：“如果锁被已经拥有该mutex的线程调用，则行为未定义”. : “互斥锁必须由当前执行线程锁定，否则，行为是未定义的。”您的实现严重依赖于未定义的行为。@Igor:是的，您完全正确。对我来说仍然很有趣的是，这个实现在我的Linux机器（64位i7CPU）上没有显示任何错误的行为，甚至包括50多个线程。