Synchronisation de l’exécution de plusieurs threads

Pour éviter les conditions de concurrence et les interblocages, il est nécessaire de synchroniser l’accès de plusieurs threads aux ressources partagées. La synchronisation est également nécessaire pour garantir que le code interdépendant est exécuté dans l’ordre approprié.

Il existe un certain nombre d’objets dont les handles peuvent être utilisés pour synchroniser plusieurs threads. Ces objets sont les suivants :

• Mémoires tampons d’entrée de console
• Événements
• Mutex
• Processus
• Sémaphores
• Threads
• Minuteurs

L’état de chacun de ces objets est signalé ou non. Lorsque vous spécifiez un handle pour l’un de ces objets dans un appel à l’une des fonctions d’attente, l’exécution du thread appelant est bloquée jusqu’à ce que l’état de l’objet spécifié soit signalé.

Certains de ces objets sont utiles pour bloquer un thread jusqu’à ce qu’un événement se produise. Par exemple, une poignée de mémoire tampon d’entrée de console est signalée en cas d’entrée non lus, telle qu’une séquence de touches ou un clic sur le bouton de la souris. Les handles de processus et de thread sont signalés à l’arrêt du processus ou du thread. Cela permet à un processus, par exemple, de créer un processus enfant, puis de bloquer sa propre exécution jusqu’à ce que le nouveau processus soit terminé.

D’autres objets sont utiles pour protéger les ressources partagées contre l’accès simultané. Par exemple, plusieurs threads peuvent avoir chacun un handle pour un objet mutex. Avant d’accéder à une ressource partagée, les threads doivent appeler l’une des fonctions d’attente pour attendre que l’état du mutex soit signalé. Lorsque le mutex est signalé, un seul thread en attente est libéré pour accéder à la ressource. L’état du mutex est immédiatement réinitialisé pour ne pas être signalé, de sorte que tous les autres threads en attente restent bloqués. Lorsque le thread a terminé avec la ressource, il doit définir l’état du mutex sur signalé pour permettre à d’autres threads d’accéder à la ressource.

Pour les threads d’un seul processus, les objets de section critique fournissent un moyen de synchronisation plus efficace que les mutex. Une section critique est utilisée comme un mutex pour permettre à un thread à la fois d’utiliser la ressource protégée. Un thread peut utiliser la fonction EnterCriticalSection pour demander la propriété d’une section critique. S’il appartient déjà à un autre thread, le thread demandeur est bloqué. Un thread peut utiliser la fonction TryEnterCriticalSection pour demander la propriété d’une section critique, sans se bloquer en cas d’échec de l’obtention de la section critique. Une fois qu’il a reçu la propriété, le thread est libre d’utiliser la ressource protégée. L’exécution des autres threads du processus n’est pas affectée, sauf s’ils tentent d’entrer dans la même section critique.

La fonction WaitForInputIdle fait attendre un thread jusqu’à ce qu’un processus spécifié soit initialisé et en attente d’une entrée utilisateur sans entrée en attente. L’appel de WaitForInputIdle peut être utile pour synchroniser les processus parents et enfants, car CreateProcess retourne sans attendre que le processus enfant termine son initialisation.

Pour plus d’informations, consultez Synchronisation.