how to reset std::condition_variable - c++

Question

I am trying to use condition variable to trigger a second thread to do some work after a certain number of buffers are in a deque.
main() is reading ADC data in a tight and time sensitive loop
main() adds the buffer to a deque (that is processed by a thread pool
manager)
the deque depth is variable so a test in main() for depth >= 4 and
then calling notify_one is not possible (ie: during heavy processing
times, the depth of the deque could be as much as 200 or 300 buffers
or as little as 4 during light processing)
thrd() never needs to signal main()
My problem is that in thrd(), after getting the signal and buffers < 4, it cycles back through the while loop and immediately gets the condition again. Is there a way to reset the cv?
deque<int> vbufs;
std::mutex thrdLock;
void thrd()
{
while (true) {
cout << "thrd() waiting for lock\n";
std::unique_lock < std::mutex > lock(thrdLock);
cout << "thrd() waiting for condition\n";
cv.wait(lock, []{ return (vbufs.size() > 0); });
thrdLock.unlock();
cout << "thrd() condition set\n";
if (vbufs.size() >= 4) { // pretend to do something with 4 buffers and remove them
std::lock_guard < std::mutex > lock(thrdLock);
vbufs.pop_front();
vbufs.pop_front();
vbufs.pop_front();
vbufs.pop_front();
cout << "thrd() reducing buffers:" << vbufs.size() << endl;
}
}
}
int main(int argc, char* argv[]) {
std::thread t1(thrd);
int tctr = 0;
while (true) {
usleep(1000);
{
cout << "main() waiting for lock\n";
std::lock_guard < std::mutex > lock(thrdLock);
vbufs.push_back(++tctr);
cout << "main() incremented buffers:" << vbufs.size() << endl;
}
cv.notify_one();
}
return 0;
}

Answer 1

You can't reset a condition variable; it makes no sense - notifying it doesn't change its state so there is nothing to reset. When it is notified only a thread already waiting can be awoken. If that thread then waits again it will not continue until the condition variable is re-notified.
If you only want to do work when there are four or more buffers, shouldn't you change your wait like this?
cv.wait(lock, []{ return (vbufs.size() >= 4); });
What's much more important is that you are potentially reading and writing vbufs simultaneously from two different threads - your if (vbufs.size() >= 4) occurs outside the lock, and so can happen at the same time as the calls to push_back. That leads to undefined behaviour, which may explain what you are seeing.

Answer 2

I found a couple of bugs in the program - corrected here:
Note: the way you were unlocking the mutex directly rather than through the std::unique_lock was causing a data race.
#include <iostream>
#include <deque>
#include <mutex>
#include <thread>
#include <chrono>
#include <condition_variable>
std::deque<int> vbufs;
std::mutex thrdLock;
std::condition_variable cv;
template<class...Ts>
void emit(Ts&&...ts)
{
static std::mutex m;
std::lock_guard<std::mutex> lg(m);
using expand = int[];
void(expand { 0, ((std::cout << std::forward<Ts>(ts)), 0)... });
}
void thrd()
{
while (true) {
emit("thrd() waiting for lock\n");
std::unique_lock < std::mutex > lock(thrdLock);
emit("thrd() waiting for condition\n");
cv.wait(lock, []{ return vbufs.size() >= 4; });
emit("thrd() condition set\n");
auto a = vbufs.front(); vbufs.pop_front();
auto b = vbufs.front(); vbufs.pop_front();
auto c = vbufs.front(); vbufs.pop_front();
auto d = vbufs.front(); vbufs.pop_front();
emit("thrd() reducing buffers:", vbufs.size(), '\n');
lock.unlock();
emit(a, ' ', b, ' ', c, ' ', d, '\n');
}
}
int main(int argc, char* argv[]) {
std::thread t1(thrd);
int tctr = 0;
while (true) {
std::this_thread::sleep_for(std::chrono::microseconds(10));
{
emit("main() waiting for lock\n");
std::lock_guard < std::mutex > lock(thrdLock);
vbufs.push_back(++tctr);
emit("main() incremented buffers:", vbufs.size(), '\n');
}
cv.notify_one();
}
t1.join(); // un-necessary in this case, but...
return 0;
}