[英]CountDownLatch equivalent
For some concurrent programming I could use the Java's CountDownLatch concept. 对于某些并发编程,我可以使用Java的CountDownLatch概念。 Is there an equivalent for C++11 or what would that concept be called in C++? 是否存在C ++ 11的等价物或者在C ++中调用该概念的内容?
What I want is to invoke a function once count has reached zero. 我想要的是一旦计数达到零就调用一个函数。
If there is non yet I would write myself a class like the following: 如果还没有,我会写一个类如下的类:
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;
};
Is something similar already available anywhere? 类似的东西已经可以在任
Scenario is: 场景是:
countdown_function counter( 2 );
counter = [success_callback]() {
success_callback();
};
startTask1Async( [counter, somework]() {
somework();
--counter;
}, errorCallback );
startTask2Async( [counter, otherwork]() {
otherwork();
--counter;
}, errorCallback );
There is a proposal covering this for the next C++ standard. 有一个提议涵盖了下一个C ++标准。 An implementation is available as part of the google concurrency library . 一个实现作为谷歌并发库的一部分提供。
I've often wished for the same thing. 我经常希望同样的事情。 Here's one way to do it ... 这是一种方法......
#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;
};
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.