Corruption du tas dans un programme multi-thread

int main(int argc, char* argv[])
{
    unsigned long id;
    InitialiserDll(&id);
    DisplayCorrection(id);
    DechargerDll(id);
    return 0;
}

class Controler {
public:
    std::thread fccThread;
    BlockingQueue<std::string> putter;
    BlockingQueue<std::string> getter;

    Controler();
    ~Controler();
};

Controler::Controler() {
    // On démarre le thread ici pour être sûr que putter et getter sont bien initialisés
    fccThread = std::thread(threadFun, std::ref(putter), std::ref(getter));
}
Controler::~Controler(){
    putter.push("!!quit!!");
    fccThread.join();
}

std::map<unsigned long, std::shared_ptr<Controler>> controlers;
unsigned long nextId = 0;

unsigned long newControler(){
    controlers.emplace(nextId, std::make_shared<Controler>());
    return nextId++;
}

int InitialiserDll(unsigned long *id){
    *id = newControler();
    return 1;
}
int DechargerDll(unsigned long id){
    controlers.erase(id);
    return 1;
}
int DisplayCorrection(unsigned long id){
    auto controler = controlers[id];

    // on envoie un message et on en attend un en retour
    controler->putter.push("controler.xml");
    std::string corrected = controler->getter.pop();
    std::cout << corrected << std::endl;
    return 1;
}

template<typename T>
class BlockingQueue
{
private:
    std::mutex mut;
    std::condition_variable cv;
    std::deque<T> queue;

public:
    void push(T const &value){
        {
            std::unique_lock<std::mutex> lock(mut);
            queue.push_front(value);
        }
        cv.notify_one();
    }

    T pop(){
        std::unique_lock<std::mutex> lock(mut);
        cv.wait(lock, [this]{ return !this->queue.empty(); });
        T rc(std::move(this->queue.back()));
        this->queue.pop_back();
        return rc;
    }

    bool tryPop(T &v){
        std::unique_lock<std::mutex> lock(mut);
        if(!cv.wait_for(lock, std::chrono::milliseconds(1), [this]{ return !this->queue.empty(); })){
            return false;
        }
        v = std::move(this->queue.back());
        this->queue.pop_back();
        return true;
    }
};

class MessageManager : public QObject {
    Q_OBJECT
    BlockingQueue<std::string> &getter;
    BlockingQueue<std::string> &putter;
    QLocalServer serv;
    QLocalSocket *sock;
    QProcess fcc;
    QTimer timer;

public:
    MessageManager(BlockingQueue<std::string> &getter,
                   BlockingQueue<std::string> &putter,
                   QObject *parent = 0);

signals:
    void correct(std::string);

public slots:
    void tic();
    void newConnection();
    void corrected();
};

void threadFun(BlockingQueue<std::string> &getter, BlockingQueue<std::string> &putter) {
    int argc = 0;
    QCoreApplication app(argc, NULL);
    MessageManager messageManager(getter, putter);
    app.exec();
}

MessageManager::MessageManager(BlockingQueue<std::string> &getter,
                               BlockingQueue<std::string> &putter,
                               QObject *parent) : QObject(parent),
                                                  getter(getter),
                                                  putter(putter),
                                                  serv(this),
                                                  fcc(this),
                                                  timer(this) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis('a', 'z');
    // génération d'un nom aléatoire de 10 caractères
    QString serverName;
    for(int i=0; i<10; i++){
        serverName += dis(gen);
    }

    connect(&serv, SIGNAL(newConnection()), this, SLOT(newConnection()));
    serv.listen(serverName);
    QStringList args;
    args << serverName;

    fcc.start("executable.exe", args);

    connect(&timer, SIGNAL(timeout()), this, SLOT(tic()));
}

// tic est exécuté périodiquement une fois que l'on est connecté à l'exécutable
void MessageManager::tic(){
    std::string mess;
    if(getter.tryPop(mess)){
        sock->write(mess.c_str());
        if(mess == "!!quit!!"){
            QCoreApplication::exit();
        }
    }
}
void MessageManager::newConnection(){
    sock = serv.nextPendingConnection();
    connect(sock, SIGNAL(readyRead()), this, SLOT(corrected()));
    timer.start(10);
}
void MessageManager::corrected(){
    QString correction = sock->readAll();
    putter.push(correction.toStdString());
}