Multithreading : Quand utiliser les classes de synchronisation MFC

Les classes multithread fournies avec MFC appartiennent à deux catégories : les objets de synchronisation (CSyncObject, CSemaphore, CMutex, CCriticalSection et CEvent) et les objets d’accès à la synchronisation (CMultiLock et CSingleLock).

Les classes de synchronisation sont utilisées lorsque l’accès à une ressource doit être contrôlé pour garantir l’intégrité de la ressource. Les classes d’accès de synchronisation sont utilisées pour accéder à ces ressources contrôlées. Cette rubrique décrit quand utiliser chaque classe.

Pour déterminer la classe de synchronisation que vous devez utiliser, posez les questions suivantes :

1. L’application doit-elle attendre que quelque chose se produise avant qu’elle puisse accéder à la ressource (par exemple, les données doivent être reçues d’un port de communication avant de pouvoir être écrites dans un fichier) ?

   Si oui, utilisez CEvent.

2. Plusieurs threads au sein de la même application peuvent-ils accéder à cette ressource à la fois (par exemple, votre application autorise jusqu’à cinq fenêtres avec des vues sur le même document) ?

   Si oui, utilisez CSemaphore.

3. Plusieurs applications peuvent-elles utiliser cette ressource (par exemple, la ressource se trouve dans une DLL) ?

   Si oui, utilisez CMutex.

   Si non, utilisez CCriticalSection.

CSyncObject n’est jamais utilisé directement. Il s’agit de la classe de base pour les quatre autres classes de synchronisation.

Exemple 1 : Utilisation de trois classes de synchronisation

Par exemple, prenez une application qui gère une liste liée de comptes. Cette application permet d’examiner jusqu’à trois comptes dans des fenêtres distinctes, mais une seule peut être mise à jour à tout moment. Lorsqu’un compte est mis à jour, les données mises à jour sont envoyées sur le réseau à une archive de données.

Cet exemple d’application utilise les trois types de classes de synchronisation. Étant donné qu’il permet d’examiner jusqu’à trois comptes à la fois, il utilise CSemaphore pour limiter l’accès à trois objets d’affichage. Lorsqu’une tentative d’affichage d’un quatrième compte se produit, l’application attend que l’une des trois premières fenêtres se ferme ou qu’elle échoue. Lorsqu’un compte est mis à jour, l’application utilise CCriticalSection pour s’assurer qu’un seul compte est mis à jour à la fois. Une fois la mise à jour réussie, elle signale CEvent, qui libère un thread en attente de l’événement à signaler. Ce thread envoie les nouvelles données à l’archive de données.

Exemple 2 : Utilisation des classes d’accès de synchronisation

Choisir la classe d’accès de synchronisation à utiliser est encore plus simple. Si votre application s’inquiète uniquement de l’accès à une seule ressource contrôlée, utilisez CSingleLock. S’il a besoin d’accéder à l’une des ressources contrôlées, utilisez CMultiLock. Dans l’exemple 1, CSingleLock aurait été utilisé, car dans chaque cas, une seule ressource est nécessaire à tout moment.

Pour plus d’informations sur l’utilisation des classes de synchronisation, consultez Multithreading : Utilisation des classes de synchronisation. Pour plus d’informations sur la synchronisation, consultez Synchronisation dans le Kit de développement logiciel (SDK) Windows. Pour plus d’informations sur la prise en charge de la multithreading dans MFC, consultez Multithreading avec C++ et MFC.

Voir aussi

Multithreading à l’aide de C++ et de MFC