CountDownLatch等效项

Question

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

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

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

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++标准，有一个涵盖这一点的proposal。实现可以作为google concurrency library的一部分提供。

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;
};