Verrouillage de multiples mutex

Je me demandais si il est possible de verrouiller plusieurs mutex dans le même temps, comme:

 Mutex1.Lock();
 {
     Mutex2.Lock();
     {
          //Code locked by mutex 1 and 2.
     }
     Mutex2.Unlock();

     //Code locked by mutex 1.
 }
 Mutex1.Unlock();

Il serait très utile dans certaines situations. Merci.

Oui, c'est possible. Il suffit de faire attention, sans la diligence voulue peut facilement conduire à des blocages.

OriginalL'auteur grimgrom | 2012-11-20

c++multithreading mutex

13

C'est possible, mais la commande de verrouillage doit être cohérente tout au long de l'application sinon blocage est une conséquence probable (si deux threads acquérir les verrous dans l'ordre inverse ensuite, chaque thread pourrait être en attente sur l'autre la libération de l'un des verrous).

Vous recommandons d'utiliser une étendue de verrouillage et déverrouillage de l'installation d'une exception de sécurité, afin d'assurer les verrous sont toujours en liberté (std::lock_guard avec std::mutex par exemple):
```
std::mutex mtx1;
std::mutex mtx2;

std::lock_guard<std::mutex> mtx1_lock(mtx1);
{
    std::lock_guard<std::mutex> mtx2_lock(mtx2);
    {
    }
}
```
Si votre compilateur ne supporte pas ces C++11 caractéristiques boost est similaire dans boost::mutex et boost::lock_guard.

Je suis l'aide de pthreads, est-il possible de protéger mon programme de blocages sans l'aide de c++11? Je suis en utilisant pthread_mutex_lock et déverrouillage de l'intérieur de l' .Lock() et .Unlock() les fonctions.
oui, il est. Le lock_guard est mentionné comme l'on fait exception de sécurité beaucoup plus simple à réaliser, mais il n'est pas nécessaire pour éviter les blocages. Pour éviter les blocages de s'assurer que les écluses sont toujours acquis dans le même ordre et toujours libéré, indépendamment de la façon dont le code de verrouillage de l'acquisition des sorties.
remarque vous pouvez facilement écrire votre propre Lock_guard classe pour votre Mutex classe. Juste Lock() dans le constructeur et Unlock() dans le destructeur. Juste être sûr que Lock_guard stocke une référence à la Mutex instance et de ne pas le copier.
Comment se fait-il y aurait une différence si j'utilise une classe supplémentaire appelée Lock_guard au lieu de simplement en utilisant ma classe Mutex. Je veux dire, je suis juste l'appel de Verrouillage/Déverrouillage dans les deux cas?
Il facilite le traitement des exceptions plus simple, c'est tout.

OriginalL'auteur hmjd
29

std::lock semble exister à cet effet.

Les verrous de la Verrouillable objets lock1, lock2, ..., lockn à l'aide d'une impasse algorithme d'évitement pour éviter un blocage.
Les objets sont verrouillés par un quelconque série d'appels à verrouiller, try_lock, déverrouiller. Si un appel de verrouiller ou déverrouiller les résultats dans une exception, unlock est appelé pour tous les objets verrouillés avant renvoi.

http://en.cppreference.com/w/cpp/thread/lock

OriginalL'auteur Pubby
6

C++17 fournit également scoped_lock dans le but spécifique de verrouillage multiples mutex qui empêche le blocage dans un RAII style, similaire à lock_guard.
```
#include<mutex>

std::mutex mtx1, mtx2;
void foo()
{
    std::scoped_lock lck{mtx1, mtx2};
    //proceed
}
```
Malheureusement courant gcc v5.4, qui est par défaut dans ubuntu n'a pas de support pour les std::scoped_lock encore. Boost analogique pourrait être utilisé.

OriginalL'auteur Passer By

Vous devez vous connecter pour publier un commentaire.