}
std::mutex exitRequestMutex;
std::condition_variable exitRequest;
std::atomic<bool> exitRequested(false);
static std::atomic_int _int(0);
void sigintHandler(int signo)
{
    _int = 1;
}
void signalThread()
{
    struct sigaction act;
    act.sa_handler = sigintHandler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    if (sigaction(SIGINT, &act, 0))
        throw SysError("installing handler for SIGINT");
    while (true) {
        sleep(1000000);
        if (_int) break;
    }
    {
        std::lock_guard<std::mutex> lock(exitRequestMutex);
        exitRequested = true;
    }
    exitRequest.notify_all();

    while (!exitRequested) {

    while (true) {

    while (!exitRequested) {

    while (true) {

    auto dispatcherThread = std::thread(&State::dispatcher, this);

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

    /* 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();

    wakeDispatcher();
    dispatcherThread.join();

    printMsg(lvlError, "exiting...");

        std::thread(signalThread).detach();

        signal(SIGINT, SIG_DFL);
        signal(SIGTERM, SIG_DFL);
        signal(SIGHUP, SIG_DFL);

        /* Ignore signals. This is inherited by the other threads. */
        sigset_t set;
        sigemptyset(&set);
        sigaddset(&set, SIGHUP);
        sigaddset(&set, SIGINT);
        sigaddset(&set, SIGTERM);
        sigprocmask(SIG_BLOCK, &set, NULL);