Comment utiliser correctement boost :: timed_mutex et scoped_lock

Question

J'essaie d'utiliser à la fois timed_mutex et scoped_lock. J'ai réussi à utiliser le scoped_lock avant de suivre quelques exemples, mais maintenant je ne trouve pas mon chemin ni je suis capable de bien comprendre la documentation de boost.

Le comportement souhaité est le suivant: essayez d'acquérir un verrou scoped_lock pour x fois, en cas de succès, renvoyez true sinon sinon false.

Actuellement, j'ai:

boost::timed_mutex _mutex; 
boost::timed_mutex::scoped_lock scoped_lock(_mutex, boost::get_system_time() + boost::posix_time::miliseconds(10)); 

Cependant lorsque je tente de trouver (grâce à la documentation de poussée ou des exemples) si cette scoped_lock retourne une valeur booléenne ou non, je ne trouve rien ou trouver des moyens vraiment différentes de le faire.

Par conséquent, je demande quelle est la bonne façon de le faire, comment cela fonctionne exactement et peut-être une indication quant à la façon de "lire" correctement la documentation de boost.

MISE À JOUR:

Alors

boost::timed_mutex _mutex; 
boost::timed_mutex::scoped_lock scoped_lock(_mutex, boost::get_system_time() + boost::posix_time::miliseconds(10)); 

if(scoped_lock.owns_lock()) { 
    // exclusive code 
} 

va créer un mutex qui lorsque je tente de verrouiller avec scoped_lock.owns_lock() va essayer d'acquérir le verrou pendant 10 millisecondes (dans ce cas) et le retour faux si le temps est écoulé et que le verrou n'a pas été acquis?

Answer 1

Si vous regardez le documentation, boost::timed_mutex::scoped_lock est juste un alias pour boost::unique_lock<timed_mutex>:

class timed_mutex: 
    boost::noncopyable 
{ 
public: 
    // ... 

    typedef unique_lock<timed_mutex> scoped_timed_lock; 
    typedef unspecified-type scoped_try_lock; 
    typedef scoped_timed_lock scoped_lock; 

    // ... 
}; 

maintenant vérifier la documentation pour boost::unique_lock, il montre qu'il existe deux façons de déterminer si vous possédez le verrou:

template<typename Lockable> 
class unique_lock 
{ 
public: 
    // ... 

    explicit operator bool() const noexcept; 
    bool owns_lock() const noexcept; 

    // ... 
}; 

Par conséquent, vous pouvez le faire soit

if(scoped_lock) { 
    // we have the lock, yay! 
} 

ou

if(scoped_lock.owns_lock()) { 
    // we have the lock, yay! 
} 

Incidemment, unique_lock a un constructeur qui prend du temps relatif comme un chrono :: durée, qui peuvent ou peuvent ne pas être plus propre que l'utilisation du temps absolu.

Edit: Compte tenu de ce code:

boost::timed_mutex _mutex; 
boost::timed_mutex::scoped_lock scoped_lock(_mutex, 
      boost::get_system_time() + boost::posix_time::miliseconds(10)); // <-- attempt to acquire mutex happens here! 

if(scoped_lock.owns_lock()) { 
    // exclusive code 
} 

La tentative d'acquérir le mutex arrive au moment où le verrou est construit, pas à l'époque owns_lock() est appelé. Oui, le code exclusif ne sera exécuté que si vous avez réussi à acquérir le mutex. Je ne suis pas sûr de ce que vous entendez par "return false" - ce code ne renvoie rien. Si owns_lock() renvoie la valeur false, vous n'avez pas réussi à acquérir le mutex et vous ne pouvez pas exécuter le code exclusif, et vous pouvez le communiquer à votre correspondant de la manière que vous souhaitez.