C++: Use sideeffects of a conditional_variable test - c++

Question

I wonder whether I can use the side effects of a conditional_variable test?
Is it guaranteed that the conditional_variable test is returning to execution if it returns true, or can there be the situation that the test returns
true, but it is called again or times out in between?
In the below example maybeCmd_locked() de-queues a cmd, however I want to
avoid that it is called 2 times for one exit of the conditional_variable wait:
if (cv.wait_until(lk, now + 100ms, [&cmd,this]{ return ((cmd = maybeCmd_locked()) != -1); }))
//g++ test.cpp -o test.exe -lstdc++ -lpthread
#include <stdlib.h>
#include <stdio.h>
#include <thread>
#include <queue>
#include <chrono>
#include <mutex>
#include <condition_variable>
using namespace std::literals::chrono_literals;
class eventLooper {
public:
eventLooper() : threadexit(false) {};
bool threadexit;
std::queue<int> cmds;
std::mutex m;
std::condition_variable cv;;
int maybeCmd_locked()
{
if (cmds.size() > 0) {
int cmd = cmds.front();
cmds.pop();
return cmd;
}
return -1;
}
int getNextCmd(void)
{
int cmd = -1;
std::unique_lock<std::mutex> lk(m);
auto now = std::chrono::system_clock::now();
if (cv.wait_until(lk, now + 100ms, [&cmd,this]{ return ((cmd = maybeCmd_locked()) != -1); }))
{
return cmd;
}
return -1;
}
int sendCmd(int cmd)
{
std::lock_guard<std::mutex> lock(m);
cmds.push(cmd);
cv.notify_one();
return 0;
}
void run(void)
{
int cmd;
printf("run\n");
std::this_thread::sleep_for(std::chrono::milliseconds(10));
while (!threadexit)
{
cmd = getNextCmd();
if (cmd == -1) {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
} else {
printf("cmd received: %d\n", cmd);
}
}
}
};
eventLooper e;
int main(int argc, char **argv)
{
(void) argc;
(void) argv;
std::thread n(&eventLooper::run, &e);
for (int i = 0; i < 10; i++)
{
std::this_thread::sleep_for(1000ms);
e.sendCmd(i);
}
std::this_thread::sleep_for(1000ms);
e.threadexit = true;
n.join();
printf("exit\n");
return 0;
}

Answer 1

The predicate is always checked under the lock, and another wait isn't done if the predicate returns true. In a simplifed version of your code (which doesn't have time outs) is:
if (cv.wait(lk, [&cmd,this]{ return ((cmd = maybeCmd_locked()) != -1); }))
{
return cmd;
}
cv.wait(lock, pred) is defined to be equivalent of:
while(!pred())
{
wait(lock);
}
In this case you can see that your predicate cannot be called twice if it returns true the first time.
Adding the timeout to the question doesn't change how this work. cv.wait_until(...) is the equivalent of:
while (!pred()) {
if (wait_until(lock, timeout_time) == std::cv_status::timeout) {
return pred();
}
}
Again, its clear that what you're worried about cannot happen.