La Sécurité des threads D'une seule variable
Je comprends le concept de la sécurité des threads. Je suis à la recherche de conseils pour simplifier la sécurité des threads en essayant de protéger une seule variable.
Dire que j'ai une variable:
double aPass;
et je veux protéger cette variable, j'ai donc créer un mutex:
pthread_mutex_t aPass_lock;
Il y a maintenant deux bonnes façons je pense le faire, mais ils ont tous deux ennuyeux inconvénients. La première est de faire un thread safe classe pour contenir la variable:
class aPass {
public:
aPass() {
pthread_mutex_init(&aPass_lock, NULL);
aPass_ = 0;
}
void get(double & setMe) {
pthread_mutex_lock(aPass_lock);
setMe = aPass_
pthread_mutex_unlock(aPass_lock);
}
void set(const double setThis) {
pthread_mutex_lock(aPass_lock);
aPass_ = setThis;
pthread_mutex_unlock(aPass_lock);
}
private:
double aPass_;
pthread_mutex_t aPass_lock;
};
Maintenant, cela vous permettra de garder aPass
totalement sûr, rien ne peut se tromper et jamais la toucher, YAY! cependant regarder tout ce désordre et d'imaginer la confusion lors de l'accès à elle. brut.
L'autre façon est de les avoir à la fois accessible et assurez-vous de verrouiller le mutex avant d'utiliser aPass.
pthread_mutex_lock(aPass_lock);
do something with aPass
pthread_mutex_unlock(aPass_lock);
Mais si quelqu'un de nouveau arrive sur le projet, ce que si vous oubliez une fois pour le verrouiller. Je n'aime pas le débogage thread problèmes qu'ils sont durs.
Est-il un bon moyen de (à l'aide de pthreads car je dois utiliser QNX qui a petit coup de pouce de soutien) Pour verrouiller les variables de type simple sans avoir besoin d'une grande classe et qui est plus sûr, puis il suffit de créer un mutex lock pour aller avec elle?
- cette variable est une variable globale? je ne pense pas u beaucoup d'autres choix.. sauf si vous voulez faire un générique thread-safe classe de conteneur - ce serait vous faire économiser un peu de code si vous avez à faire à un deuxième var.
- tu veux dire basé sur un modèle de classe? cela semble assez bon.
- aussi, n'est-il pas possible par ur de la conception de reproduire le var? apass est une classe pour que je puisse avoir autant d'objets que je veux
- ouais, mais si je veux protéger un int? 2 classes, maintenant, un char et un time_t, 4 classes etc ...
- Utilisation
std::atomic<double>
si vous avez le C++11.
Vous devez vous connecter pour publier un commentaire.
À elabourate sur ma solution, ce serait quelque chose comme cela.
En outre, afin de la rendre unique, il peut être préférable de faire tous les opérateurs et les membres de la statique. Pour que cela fonctionne, vous devez utiliser PFI
j'.e
à condition que vous avez le C++11.
Vous pouvez facilement faire votre propre classe qui verrouille le mutex de la construction, et il se déverrouille de la destruction. De cette façon, peu importe ce qui se passe le mutex sera libéré sur le retour, même si une exception est levée, ou de n'importe quel chemin est pris.
La variable m_SharedVar est assurée exclusion mutuelle entre
Function1()
etFunction2()
, et sera toujours débloqué sur le retour.boost a construire des types pour ce faire: boost::scoped_locked, boost::lock_guard.
Vous pouvez créer une classe qui agissent comme un générique wrapper autour de votre variable de synchronisation de l'accès.
Ajouter la surcharge d'opérateur d'affectation et vous avez terminé.
Envisager l'utilisation
RAII idiom
, code ci-dessous est juste l'idée, ce n'est pas testé:Vous pouvez modifier votre aPass classe en utilisant les opérateurs au lieu de get/set:
Utilisation:
Ceci pourrait être basé sur un modèle de soutien à d'autres types. À noter toutefois qu'un mutex est exagéré dans ce cas. Généralement, les barrières de la mémoire sont assez pour protéger les charges et les magasins de petits types de données. Si possible, vous devriez utiliser le C++11
std::atomic<double>
.