How can I avoid a race condition between these two interlated threads - c++

Question

The little program I wrote consistently gets block due to what I think is a race condition. Can somebody kindly help me identifying my error?
There is one function, process_two which does some tasks and then relies on another function to update some underlying data structure before it may continue. Note: this function is run by multiple threads simultaneously This function is:
void process_two(int n_tasks) {
while (total_iter < 100) {
// do some work
iter_since_update += n_tasks;
total_iter += n_tasks;
std::shared_lock<std::shared_mutex> lk(mutex);
cv.wait(lk, [&] { return data_updated; });
data_updated = false;
lk.unlock();
}
}
The function does some work and increments a count of the completed tasks. Then it acquires a shared lock (if possible), and waits for a condition variable. After having waited, the thread resets the condition and unlocks the mutex. The function updating the underlying data structure is:
void process_one(int threshold) {
while (total_iter < 100) {
if (iter_since_update >= threshold) {
std::lock_guard<std::shared_mutex> lk(mutex);
// updating
data_updated = true;
iter_since_update = 0;
cv.notify_all();
}
}
}
Whenever the other function has made some number of iterations, process_one acquires a lock and updates the data. It also resets the counter of iterations and notifies the other threads. Finally, the entire program is:
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>
#include <vector>
int iter_since_update(0);
bool data_updated(true);
std::shared_mutex mutex;
std::condition_variable_any cv;
int total_iter(0);
void process_two(int n_tasks) {
while (total_iter < 100) {
// do some work
iter_since_update += n_tasks;
total_iter += n_tasks;
std::shared_lock<std::shared_mutex> lk(mutex);
cv.wait(lk, [&] { return data_updated; });
data_updated = false;
lk.unlock();
}
}
void process_one(int threshold) {
while (total_iter < 100) {
if (iter_since_update >= threshold) {
std::lock_guard<std::shared_mutex> lk(mutex);
// updating
data_updated = true;
iter_since_update = 0;
cv.notify_all();
}
}
}
int main() {
int total_tasks(10);
int n_threads(1);
int n_tasks = total_tasks / n_threads;
std::thread update_thread([&]() { process_one(total_tasks);});
std::vector<std::thread> threads;
for (int i = 0; i < n_threads; i++)
threads.push_back(std::thread([&]() { process_two(n_tasks); }));
while (total_iter < 100) {
;
}
update_thread.join();
for (int i = 0; i < n_threads; i++) threads[i].join();
}
I set a total number of tasks and let each thread running process_two do a fraction of these tasks. Whenever I set n_threads = 1, the program completes almost always. Whenever I set n_threads = 2, the program always failed.
I am new to multithreading in c++ and would greatly appreciate any suggestion as to what I am doing wrong. I suspect that the condition in process_one (waiting until a number of iterations have been done) is wrong. Whenever I saw condition variables being used in examples in Anthony Williams' wonderful book (see section 4.1.1. in the 2012 edition) one function was operating until an external condition is negated but here I have both processes depending on each other. Can somebody kindly point out what I can improve?