boost :: mutex/Come verificare se un mutex è bloccato

Question

Lo so, lo so, il titolo del mio messaggio può sembrare provocatorio, dal momento che boost :: mutex intenzionalmente non esporre blocco/sblocco (per evitare la morte serrature).

Tuttavia la documentazione di boost è piuttosto corta su questi aspetti (per non dire altro), quindi mi chiedo se qualcuno può aiutarmi nel seguente caso d'uso.

Supponiamo di avere una classe Foo, che ha:
- un distruttore che richiede un po 'di tempo per completare
- un metodo che viene chiamato da un thread distinti, ma non dovrebbe essere chiamato durante la distruzione

class Foo 
{ 
public: 

    virtual ~Foo() 
    { 
    //Time consuming operations here 
    } 


    //Method called by a timer belonging to a distinct class 
    void OnTimer() 
    { 
    //Other time consuming stuff. Should not be called during destruction ! 
    } 


}; 

ho cercato (senza successo) per implementare una versione basata su boost :: mutex

//boost::mutex implementation 
class Foo 
{ 
public: 
    Foo() 
    { 
    } 

    virtual ~Foo() 
    { 
    { 
     boost::mutex::scoped_lock lock(mDisposingMutex); 
     //Time consuming operations here 
    } 
    } 


    //Method called by a timer belonging to a distinct class 
    void OnTimer() 
    { 
    { 
     //Imaginary code here: mutex::locked() method is private !!! 
     if (! mDisposingMutex.locked()) 
     return; 
    }  
    //Other time consuming stuff. Should not be called during destruction ! 
    } 

private: 
    boost::mutex mDisposingMutex; 
}; 

Am I del tutto sbagliato? Qualcuno può dirmi come dovrebbe essere fatto con boost :: mutex?

Grazie!

Answer 1

Se impegnano a utilizzare Lockable::lock() nel corpo distruttore, si potrebbe avere la funzione OnTimer() uso Lockable::try_lock(), e procedere solo se tale funzione restituisce true. Che avrà OnTimer() messo in attesa se OnTimer() inizia per primo, ma è ancora non risolve il problema del distruttore in esecuzione, finendo e rilasciando il mutex, e quindi OnTimer() iniziando e afferrando con successo il mutex.

Tale sequenza è probabile nel regno di un comportamento indefinito, ma quella maledizione non gli impedirà di accadere. L'utilizzo di un flag di stato in aggiunta al mutex - simile a quello descritto nel mio commento sopra - potrebbe consentire di rilevare quest'ultimo caso e impedire a OnTimer() di fare qualcosa oltre la lettura della bandiera. Ad un certo punto, però, questo è solo mettere Band-Aids in cima al cerotto.

Answer 2

mutex :: try_lock()

Answer 3

@Seh: Sono assolutamente d'accordo che questo è un odore di codice e dovrei (e lo farò) correggere la causa principale.

Tuttavia, nella speranza di aiutare chiunque incontrasse lo stesso problema di me (cioè combattendo con il documento di potenziamento), ho cercato di implementare il tuo suggerimento. Il codice qui sotto ora compila correttamente (anche se il codice odore è ora molto forte)

#include <boost/thread/mutex.hpp> 

//boost::mutex implementation 
class Foo 
{ 
public: 
    Foo() : 
    mIsDisposing(false) 
    { 
    } 

    virtual ~Foo() 
    { 
    { 
     boost::try_mutex::scoped_try_lock lock(mDisposingMutex); 
     if (! lock.locked()) 
     { 
     //Die by horrible death, or wait before trying again... 
     } 
     else 
     { 
     mIsDisposing = true; 
     } 
     //Time consuming operations here 
    } 

    } 


    //Method called by a timer belonging to a distinct class 
    void OnTimer() 
    { 
    { 
     boost::try_mutex::scoped_try_lock lock(mDisposingMutex); 
     if (! lock.locked() || mIsDisposing) 
     { 
     return;  
     } 
    }  
    //Other time consuming stuff. Should not be called during destruction ! 
    } 

private: 
    boost::try_mutex mDisposingMutex; 
    bool mIsDisposing; 
};