java - CountDownLatch 等效

Question

对于一些并发编程，我可以使用 Java 的CountDownLatch概念。是否有 C++11 的等价物，或者在 C++ 中该概念被称为什么？

我想要的是在计数达到零后调用一个函数。

如果还没有，我会给自己写一个如下的类：

class countdown_function {
public:
  countdown_function( size_t count );
  countdown_function( const countdown_function& ) = default;
  countdown_function( countdown_function&& ) = default;
  countdown_function& operator=( const countdown_function& ) = default;
  countdown_function& operator=( countdown_function&& ) = default;
  // Callback to be invoked
  countdown_function& operator=(std::function<void()> callback);
  countdown_function& operator--();
private:
  struct internal {
    std::function<void()> _callback;
    size_t _count;
    // + some concurrent handling
  };
  // Make sure this class can be copied but still references
  // same state
  std::shared_ptr<internal> _state;
};

类似的东西是否已经在任何地方可用？

场景是：

countdown_function counter( 2 );
counter = [success_callback]() {
  success_callback();
};

startTask1Async( [counter, somework]() {
  somework();
  --counter;
}, errorCallback );

startTask2Async( [counter, otherwork]() {
  otherwork();
  --counter;
}, errorCallback );

Answer 1

有一个针对下一个 C++ 标准的提案。谷歌并发库中提供了一个实现。

Answer 2

我经常希望得到同样的东西。这是一种方法...

#include <chrono>
#include <condition_variable>
#include <mutex>

class CountDownLatch {
public:
    explicit CountDownLatch(const unsigned int count): m_count(count) { }
    virtual ~CountDownLatch() = default;

    void await(void) {
        std::unique_lock<std::mutex> lock(m_mutex);
        if (m_count > 0) {
            m_cv.wait(lock, [this](){ return m_count == 0; });
        }
    }

    template <class Rep, class Period>
    bool await(const std::chrono::duration<Rep, Period>& timeout) {
        std::unique_lock<std::mutex> lock(m_mutex);
        bool result = true;
        if (m_count > 0) {
            result = m_cv.wait_for(lock, timeout, [this](){ return m_count == 0; });
        }

        return result;
    }

    void countDown(void) {
        std::unique_lock<std::mutex> lock(m_mutex);
        if (m_count > 0) {
            m_count--;
            m_cv.notify_all();
        }
    }

    unsigned int getCount(void) {
        std::unique_lock<std::mutex> lock(m_mutex);
        return m_count;
    }

protected:
    std::mutex m_mutex;
    std::condition_variable m_cv;
    unsigned int m_count = 0;
};