multithreading - 在 C++11 中实现 boost::barrier

Question

我一直在尝试让项目摆脱所有 boost 引用并切换到纯 C++11。

在某一时刻，线程工作线程被创建，等待屏障发出“go”命令，完成工作(分布在 N 个线程中)并在所有线程完成时进行同步。基本思想是主循环给出执行顺序(boost::barrier .wait())并使用相同的函数等待结果。

我在另一个项目中实现了一个基于 Boost 版本的定制 Barrier，一切都运行良好。实现如下:

Barrier.h:

class Barrier {
public:
    Barrier(unsigned int n);
    void Wait(void);
private:
    std::mutex counterMutex;
    std::mutex waitMutex;

    unsigned int expectedN;
    unsigned int currentN;
};

Barrier.cpp

Barrier::Barrier(unsigned int n) {
    expectedN = n;
    currentN = expectedN;
}

void Barrier::Wait(void) {
    counterMutex.lock();

    // If we're the first thread, we want an extra lock at our disposal

    if (currentN == expectedN) {
        waitMutex.lock();
    }

    // Decrease thread counter

    --currentN;

    if (currentN == 0) {
        currentN = expectedN;
        waitMutex.unlock();

        currentN = expectedN;
        counterMutex.unlock();
    } else {
        counterMutex.unlock();

        waitMutex.lock();
        waitMutex.unlock();
    }
}

此代码已在 iOS 和 Android 的 NDK 上使用，没有任何问题，但在 Visual Studio 2013 项目上尝试时，似乎只有锁定互斥体的线程才能解锁它(断言:解锁无主互斥体)。

是否有任何适用于 C++11 的非旋转(阻塞，例如这个)版本的屏障可供我使用？我只能找到使用忙等待的障碍，这是我想阻止的事情(除非确实没有理由)。

Answer 1

class Barrier {
public:
    explicit Barrier(std::size_t iCount) : 
      mThreshold(iCount), 
      mCount(iCount), 
      mGeneration(0) {
    }

    void Wait() {
        std::unique_lock<std::mutex> lLock{mMutex};
        auto lGen = mGeneration;
        if (!--mCount) {
            mGeneration++;
            mCount = mThreshold;
            mCond.notify_all();
        } else {
            mCond.wait(lLock, [this, lGen] { return lGen != mGeneration; });
        }
    }

private:
    std::mutex mMutex;
    std::condition_variable mCond;
    std::size_t mThreshold;
    std::size_t mCount;
    std::size_t mGeneration;
};