Simple Synchronisation Des Threads
J'ai besoin d'un simple "un à un" verrou sur une section de code. Considérons la fonction func
qui peut être exécuté à partir de plusieurs threads:
void func()
{
//locking/mutex statement goes here
operation1();
operation2();
//corresponding unlock goes here
operation3();
}
J'ai besoin pour vous assurer que operation1
et operation2
toujours exécuter "ensemble". Avec C# je voudrais utiliser un simple lock
bloc autour de ces deux appels. Qu'est-ce que le C++/Win32/MFC équivalent?
Sans doute une sorte de Mutex
?
Vous devez vous connecter pour publier un commentaire.
Critique des sections de travail (ils sont plus légers que les mutex.) InitializeCriticalSection, EnterCriticalSection, LeaveCriticalSection, et DeleteCriticalSection sont les fonctions de chercher sur MSDN.
EDIT:
Les sections critiques sont plus rapides que les mutex depuis les sections critiques sont principalement en mode utilisateur primitives - dans le cas d'une uncontended acquérir (c'est généralement le cas le plus courant) il n'y a pas de système d'appel dans le noyau, et l'acquisition d'prend de l'ordre de plusieurs dizaines de cycles. Un noyau commutateur est de plus en plus cher (de l'ordre de plusieurs centaines de cycles). Le seul moment où les sections critiques d'appel dans le noyau est dans le but de bloquer, ce qui implique d'attendre sur un noyau primitif, (soit mutex ou de l'événement). L'acquisition d'un mutex implique toujours un appel dans le noyau, et donc les ordres de grandeur plus lent.
Toutefois, les sections critiques ne peut être utilisé pour synchroniser des ressources dans un processus. Afin de synchroniser à travers de multiples processus, un mutex est nécessaire.
Fixation Michael solution ci-dessus.
Michael solution est parfait pour des applications C. Mais lorsqu'il est utilisé en C++ ce style est déconseillée en raison de la posability des exceptions. Si une exception se produit dans operation1 ou operation2 puis la section critique ne sera pas correctement gauche et tous les autres threads bloc d'attente.
La meilleure méthode serait d'utiliser une section critique, l'utilisation EnterCriticalSection et LeaveCriticalSection. La seule ticky partie est que vous devez initialiser une section critique d'abord avec InitializeCriticalSection. Si ce code est dans une classe, mettre l'initialisation dans le constructeur et le CRITICAL_SECTION structure de données en tant que membre de la classe. Si le code ne fait pas partie d'une classe, vous devrez probablement utiliser une approche globale ou quelque chose de similaire pour s'assurer qu'il est initialisée une fois.
à l'aide de MFC:
Définir un objet de synchronisation. ( Mutext ou de la section Critique)
1.1 Si plusieurs threads appartenant à différents processus entre dans le
func() puis utiliser CMutex.
1.2. Si plusieurs threads d'un même processus entre la touche func() puis utiliser
CCriticalSection.
Permet de dire que nous avons défini en section critique
Vous pouvez essayer ceci: