How to write a std::queue with a thread which only executes the "newest unexecuted task" from the queue? - queue

Question

I need to create a std::queue of tasks which is executed by a thread which is only executing the latest task from the list.
The tasks are let's say for example file copy tasks. But here is the important part. I don't have to always run through the whole queue of tasks. I just want to execute the latest unexecuted task from the queue and empty the queue right after popping out the task to execute. You see this part can be tricky. I have to be careful to not clear the queue with an unexecuted task pending :-)
Following is the complete code:
#include <atomic>
#include <functional>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
using CopyTask = std::function<void(void)>;
class TaskQueue {
public:
~TaskQueue() {
StopThread();
}
void CopyTaskCompleted() {
std::unique_lock<std::mutex> que_lock(m_push_mutex);
m_trigger = true;
que_lock.unlock();
m_condition_variable.notify_one();
std::cout << " CopyTaskCompleted called " << std::endl;
}
void PushCopyTask(CopyTask task) {
std::lock_guard<std::mutex> lock(m_push_mutex);
std::cout << " PushCopyTask called " << std::endl;
if (!m_thread.joinable()) {
StartThreadLooper();
task();
return;
}
if (!m_queue.empty()) {
m_queue.push(task);
} else {
// If the queue is empty then there are no pending tasks. Simply run the task without posting it on the queue
task();
}
}
private:
std::queue<CopyTask> m_queue;
std::mutex m_queue_mutex;
std::mutex m_push_mutex;
std::condition_variable m_condition_variable;
std::thread m_thread;
std::atomic<bool> m_running {false};
bool m_trigger {false};
void StartThreadLooper() {
m_running = true;
std::cout << " Looper thread going to start " << std::endl;
m_thread = std::thread( [this] {
while (m_running) {
std::cout << " Looper thread running " << std::endl;
WaitForNotification();
if (!m_queue.empty()) {
// I want to execute the latest task from the queue here and cancel the rest of the tasks
CopyTask latest_task_to_execute = m_queue.back();
m_queue = {};
latest_task_to_execute();
}
}
});
}
void StopThread() {
std::unique_lock<std::mutex> lock(m_queue_mutex);
m_running = false;
if (m_thread.joinable()) {
try {
m_thread.join();
}
catch (const std::exception& e) {
// Log
}
}
std::cout << " Looper thread exiting " << std::endl;
}
void WaitForNotification() {
std::unique_lock<std::mutex> que_lock(m_queue_mutex);
m_condition_variable.wait(que_lock, [this] {
return m_trigger;
});
m_trigger = false;
}
};
int main() {
std::cout << " -- Beginining of program -- " << std::endl;
TaskQueue task_queue;
task_queue.PushCopyTask([&task_queue](){
std::thread t1([&] {
std::this_thread::sleep_for(std::chrono::milliseconds(70));
std::cout << " PushCopyTask number 1 fninshed executing " << std::endl;
task_queue.CopyTaskCompleted();
});
});
task_queue.PushCopyTask([&task_queue](){
std::thread t2([&] {
std::this_thread::sleep_for(std::chrono::milliseconds(70));
std::cout << " PushCopyTask number 2 fninshed executing " << std::endl;
task_queue.CopyTaskCompleted();
});
});
task_queue.PushCopyTask([&task_queue](){
std::thread t3([&] {
std::this_thread::sleep_for(std::chrono::milliseconds(70));
std::cout << " PushCopyTask number 3 fninshed executing " << std::endl;
task_queue.CopyTaskCompleted();
});
});
task_queue.PushCopyTask([&task_queue](){
std::thread t4([&] {
std::this_thread::sleep_for(std::chrono::milliseconds(70));
std::cout << " PushCopyTask number 4 fninshed executing " << std::endl;
task_queue.CopyTaskCompleted();
});
});
std::cout << " -- Ending of program -- " << std::endl;
return 0;
}
But above does not work. It seems like I am doing something wrong with the condition_variable?
How can write a tasks queue with a simple public API like above class TaskQueue has where I can pass a method to execute and it should always execute the latest method when it gets a chance.
Dev env:
Macos Big Sure with C++ clang compiler

Answer 1

Multiple things here:
You're using a different mutex when setting m_triggered than with the condition variable. You need to use the same one.
You're not securing the acces to m_queue via mutex in the worker thread
PushCopyTask will never push anything to the queue. It takes the mtx, sees that the queue is empty, then executes the task and returns. Simultaneous calls will block while trying to take the mtx.
If only the latest q element is supposed to be executed, why use a queue at all? I suggest using std::optional instead. Then push can just overwrite it.