如何重置std :: condition_variable

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