bool exitRequested(false);

std::atomic<bool> exitRequested(false);

    std::mutex queueMonitorMutex;
    std::condition_variable queueMonitorWakeup;

    std::condition_variable_any runnableCV;

    std::condition_variable_any runnableWakeup;

    void queueMonitorThreadEntry();

    void queueMonitor();

void State::queueMonitorThreadEntry()

void State::queueMonitor()

    while (true) {

    while (!exitRequested) {

            std::unique_lock<std::mutex> lock(exitRequestMutex);
            exitRequest.wait_for(lock, std::chrono::seconds(5));
            if (exitRequested) break;

            std::unique_lock<std::mutex> lock(queueMonitorMutex);
            queueMonitorWakeup.wait_for(lock, std::chrono::seconds(5));

    runnableCV.notify_one();

    runnableWakeup.notify_one();

            while (runnable_->empty())
                runnable_.wait(runnableCV);

            while (runnable_->empty() && !exitRequested)
                runnable_.wait(runnableWakeup);
            if (exitRequested) break;

    queueMonitorThread = std::thread(&State::queueMonitorThreadEntry, this);

    queueMonitorThread = std::thread(&State::queueMonitor, this);

    std::vector<std::thread> builderThreads;

        std::thread(&State::builderThreadEntry, this, n).detach();

        builderThreads.push_back(std::thread(&State::builderThreadEntry, this, n));
    /* Wait for SIGINT. */
    {
        std::unique_lock<std::mutex> lock(exitRequestMutex);
        while (!exitRequested)
            exitRequest.wait(lock);
    }
    printMsg(lvlError, "exiting...");

    /* Shut down the various threads. */
    { std::lock_guard<std::mutex> lock(queueMonitorMutex); } // barrier
    queueMonitorWakeup.notify_all();

    { auto runnable_(runnable.lock()); } // barrier
    runnableWakeup.notify_all();
    for (auto & thread : builderThreads) thread.join();