Question

I’m writing a program in which I need to make sure a particular function is called is not being executed in more than one thread at a time.

Here I’ve written some simplified pseudocode that does exactly what is done in my real program.

mutex _enqueue_mutex;
mutex _action_mutex;
queue _queue;
bool  _executing_queue;

// called in multiple threads, possibly simultaneously
do_action() {
  _enqueue_mutex.lock()
  object o;
  _queue.enqueue(o);
  _enqueue_mutex.unlock();

  execute_queue();
}

execute_queue() {
  if (!executing_queue) {
    _executing_queue = true;
    enqueue_mutex.lock();
    bool is_empty = _queue.isEmpty();
    _enqueue_mutex.lock();
    while (!is_empty) {
      _action_mutex.lock();

      _enqueue_mutex.lock();
      object o = _queue.dequeue();
      is_empty = _queue.isEmpty();
      _enqueue_mutex.unlock();

      // callback is called when "o" is done being used by "do_stuff_to_object_with_callback" also, this function doesn't block, it is executed on its own thread (hence the need for the callback to know when it's done)
      do_stuff_to_object_with_callback(o, &some_callback);
    }
    _executing_queue = false;
  }
}

some_callback() {
  _action_mutex.unlock();
}

Essentially, the idea is that _action_mutex is locked in the while loop (I should say that lock is assumed to be blocking until it can be locked again), and expected to be unlocked when the completion callback is called (some_callback in the above code).

This, does not seem to be working though. What happens is if the do_action is called more than once at the same time, the program locks up. I think it might be related to the while loop executing more than once simultaneously, but I just cant see how that could be the case. Is there something wrong with my approach? Is there a better approach?

Thanks

Answer 1

A queue that is not specifically designed to be multithreaded (multi-producer multi-consumer) will need to serialize both eneueue and dequeue operations using the same mutex.

(If your queue implementation has a different assumption, please state it in your question.)

The check for _queue.isEmpty() will also need to be protected, if the dequeue operation is prone to the Time of check to time of use problem.

That is, the line
object o = _queue.dequeue();
needs to be surrounded by _enqueue_mutex.lock(); and _enqueue_mutex.unlock(); as well.