Lo sblocco di mutex fallisce in modo strano

Question

Sto giocando con alcuni socket, thread e mutex. La mia domanda riguarda fili e mutex:

int ConnectionHandler::addNewSocket(){ 

    this->connectionList_mutex.lock(); 
    std::cout << "test1" << std::endl; 
    this->connectionList_mutex.unlock(); 

    return 0; 
} 

int ConnectionHandler::main(){ 
    while(true){ 
     this->connectionList_mutex.lock(); 
     std::cout << "test2" << std::endl; 
     this->connectionList_mutex.unlock(); 
    } 

}` 

La funzione principale è in esecuzione in un thread, mentre l'addNewSocket viene chiamato da un altro thread. Il problema è che, quando addNewSocket viene chiamato una volta (dal secondo thread), lo sblocco successivo da parte di thread 1 (main) fallirà con uno strano "SIGABRT di segnale". Ho lavorato due giorni su questo ora, ma non sono riuscito a farlo riparare, purtroppo. Spero che puoi aiutarmi.

Modifica: ConnectionHandler è una classe che ha connectionList_mutex come membro.

Modifica: A volte viene visualizzato anche questo errore: "Asserzione non riuscita: (ec == 0), funzione sblocco, file /SourceCache/libcxx/libcxx-65.1/src/mutex.cpp, riga 44." ma si verifica casualmente.

Modifica: Questa è l'intera classe (Ridotta al minimo, dovrebbe essere indipendente dal contesto in una certa misura, ma si blocca quando la inserisco subito dopo un client collegato e funziona se la metto subito dopo l'avvio:

..

class ConnectionHandler{ 
public: 
    ConnectionHandler(); 
    int addNewSocket(); 
private: 
    int main(); 
    static void start(void * pThis); 

    std::mutex connectionList_mutex; 
}; 

ConnectionHandler::ConnectionHandler(){ 
    std::thread t(&this->start, this); 
    t.detach(); 
} 
void ConnectionHandler::start(void * pThis){ 
    ConnectionHandler *handlerThis; 
    handlerThis = (ConnectionHandler *)pThis; 
    handlerThis->main(); 
} 


int ConnectionHandler::addNewSocket(){ 

    this->connectionList_mutex.lock(); 
    std::cout << "test1" << std::endl; 
    this->connectionList_mutex.unlock(); 

    return 0; 
} 

int ConnectionHandler::main(){ 
    while(true){ 
     this->connectionList_mutex.lock(); 
     std::cout << "test2" << std::endl; 
     std::this_thread::sleep_for(std::chrono::milliseconds(100)); 
     this->connectionList_mutex.unlock(); 

    } 

} 

Answer 1

la mia ipotesi è che il vostro oggetto ConnectionHandler viene distrutto da qualche Inoltre, è stato definito ConnectionHandler::start in modo stupido

in primo luogo, ConnectionHandler::start dovrebbero essere definite in questo modo:

void ConnectionHandler::start(ConnectionHandler * pThis){ 
    pThis->main(); 
} 

La classe C++ 11 ::std::thread è perfettamente in grado di preservare il tipo dell'argomento della funzione, pertanto non è necessario ricorrere a void *.

In secondo luogo, aggiungere questo codice:

void ConnectionHandler::~ConnectionHandler(){ 
    const void * const meptr = this; 
    this->connectionList_mutex.lock(); 
    ::std::cout << "ConnectionHandler being destroyed at " << meptr << ::std::endl; 
    this->connectionList_mutex.unlock(); 
} 

e cambiare il costruttore di leggere:

ConnectionHandler::ConnectionHandler(){ 
    const void * const meptr = this; 
    ::std::cout << "ConnectionHandler being created at " << meptr << ::std::endl; 
    std::thread t(&this->start, this); 
    t.detach(); 
} 

Questo ti mostrerà quando l'oggetto ConnectionHandler viene distrutta. E la mia ipotesi è che il tuo codice lo stia distruggendo mentre il tuo thread separato è ancora in esecuzione.

La cosa meptr è perché operator << ha un sovraccarico per void * che stampa il valore del puntatore. La stampa del valore del puntatore per this consente di abbinare le chiamate al costruttore e al distruttore se si creano più oggetti ConnectionHandler.

Edit: Poiché si è scoperto che ero corretto, ecco come mi sento di raccomandare che si scrive la classe gioco ConnectionHandler:

#include <iostream> 
#include <atomic> 
#include <thread> 
#include <chrono> 
#include <mutex> 

class ConnectionHandler { 
public: 
    ConnectionHandler(); 
    ~ConnectionHandler(); 
    ConnectionHandler(const ConnectionHandler &) = delete; 
    const ConnectionHandler &operator =(const ConnectionHandler &) = delete; 

    int addNewSocket(); 

private: 
    int main(); 
    static void start(ConnectionHandler * pThis); 

    ::std::mutex connectionList_mutex; 
    volatile ::std::atomic_bool thread_shutdown; 
    ::std::thread thread; 
}; 

ConnectionHandler::ConnectionHandler() 
    : thread_shutdown(false), thread(&this->start, this) 
{ 
} 

ConnectionHandler::~ConnectionHandler() 
{ 
    thread_shutdown.store(true); 
    thread.join(); 
} 

void ConnectionHandler::start(ConnectionHandler * pThis){ 
    pThis->main(); 
} 

int ConnectionHandler::addNewSocket(){ 
    ::std::lock_guard< ::std::mutex> lock(connectionList_mutex); 
    ::std::cout << "test1" << ::std::endl; 

    return 0; 
} 

int ConnectionHandler::main(){ 
    while(!thread_shutdown.load()){ 
     ::std::lock_guard< ::std::mutex> lock(connectionList_mutex); 
     ::std::cout << "test2" << ::std::endl; 
     ::std::this_thread::sleep_for(::std::chrono::milliseconds(100)); 

    } 
    return 0; 
}