Cola segura para subprocesos de C++11

Solo mirándolo, cuando compruebas una variable de condición, lo mejor es usar un bucle while (de modo que si se despierta y aún no es inválido, lo compruebes de nuevo). Acabo de escribir una plantilla para una cola asíncrona, espero que esto ayude.

#ifndef SAFE_QUEUE
#define SAFE_QUEUE

#include <queue>
#include <mutex>
#include <condition_variable>

// A threadsafe-queue.
template <class T>
class SafeQueue
{
public:
  SafeQueue(void)
    : q()
    , m()
    , c()
  {}

  ~SafeQueue(void)
  {}

  // Add an element to the queue.
  void enqueue(T t)
  {
    std::lock_guard<std::mutex> lock(m);
    q.push(t);
    c.notify_one();
  }

  // Get the "front"-element.
  // If the queue is empty, wait till a element is avaiable.
  T dequeue(void)
  {
    std::unique_lock<std::mutex> lock(m);
    while(q.empty())
    {
      // release lock as long as the wait and reaquire it afterwards.
      c.wait(lock);
    }
    T val = q.front();
    q.pop();
    return val;
  }

private:
  std::queue<T> q;
  mutable std::mutex m;
  std::condition_variable c;
};
#endif

Esto es probablemente cómo debe hacerlo:

void push(std::string&& filename)
{
    {
        std::lock_guard<std::mutex> lock(qMutex);

        q.push(std::move(filename));
    }

    populatedNotifier.notify_one();
}

bool try_pop(std::string& filename, std::chrono::milliseconds timeout)
{
    std::unique_lock<std::mutex> lock(qMutex);

    if(!populatedNotifier.wait_for(lock, timeout, [this] { return !q.empty(); }))
        return false;

    filename = std::move(q.front());
    q.pop();

    return true;    
}

Agregando a la respuesta aceptada, yo diría que implementar una cola correcta de multi productores / multi consumidores es difícil (más fácil desde C++11, sin embargo)

Te sugiero que pruebes la (muy buena) lock free boost library, la estructura "queue" hará lo que quieras, con garantías de wait-free/lock-free y sin la necesidad de un compilador de C++11.

Estoy agregando esta respuesta ahora porque la biblioteca libre de bloqueos es bastante nueva para impulsar (desde 1.53 I creer)

Reescribiría su función dequeue como:

std::string FileQueue::dequeue(const std::chrono::milliseconds& timeout)
{
    std::unique_lock<std::mutex> lock(qMutex);
    while(q.empty()) {
        if (populatedNotifier.wait_for(lock, timeout) == std::cv_status::timeout ) 
           return std::string();
    }
    std::string ret = q.front();
    q.pop();
    return ret;
}

Es más corto y no tiene código duplicado como el tuyo. Solo problema que puede esperar más tiempo que el tiempo de espera. Para evitar que tenga que recordar la hora de inicio antes del bucle, verifique el tiempo de espera y ajuste el tiempo de espera en consecuencia. O especifique tiempo absoluto en la condición de espera.

También hay una solución simplista para este caso, aún no lo intenté, pero creo que es una buena solución. https://developer.gnome.org/glib/2.36/glib-Asynchronous-Queues.html#g-async-queue-new

Puede que te guste lfqueue, https://github.com/Taymindis/lfqueue . Es bloquear la cola concurrente libre. Actualmente lo estoy usando para consumir la cola de múltiples llamadas entrantes y funciona como un encanto.