Sémaphores
Mise à jour : novembre 2007
La classe Semaphore représente un sémaphore nommé (à l'échelle du système) ou local. Les sémaphores Windows sont des sémaphores de comptage qui peuvent être utilisés pour contrôler l'accès à un pool de ressources.
Gestion d'une ressource limitée
Les threads entrent dans le sémaphore en appelant la méthode WaitOne qui est héritée de la classe WaitHandle. Lorsque l'appel est retourné, le décompte sur le sémaphore est décrémenté. Lorsqu'un thread demande à entrer et que le décompte est égal à zéro, le thread se bloque. Lorsque les threads libèrent le sémaphore en appelant la méthode Release, les threads bloqués sont autorisés à entrer. Il n'existe aucun ordre garanti (tel que Premier entré, premier sorti (FIFO, First In First Out) ou Dernier entré, premier sorti (LIFO, Last In First Out)) pour l'entrée des threads bloqués dans le sémaphore.
Un thread peut entrer plusieurs fois dans le sémaphore en appelant la méthode WaitOne à plusieurs reprises. Pour libérer le sémaphore, le thread peut appeler la surcharge de la méthode Release() autant de fois ou appeler la surcharge de la méthode Release(Int32) et spécifier le nombre d'entrées à libérer.
Sémaphores et identité de thread
La classe Semaphore n'applique pas l'identité de thread sur les appels aux méthodes WaitOne et Release. Par exemple, un scénario d'utilisation classique pour les sémaphores implique un thread producteur et un thread consommateur, un thread incrémentant toujours le nombre de sémaphores et l'autre le décrémentant.
Il est de la responsabilité du programmeur de garantir qu'un thread ne libère pas le sémaphore trop souvent. Par exemple, supposons que le décompte maximal d'un sémaphore est de deux et que le thread A et le thread B entrent dans le sémaphore. Si une erreur de programmation dans le thread B le conduit à appeler Release deux fois, les deux appels aboutissent. Le décompte sur le sémaphore est complet, et lorsque le thread A appelle enfin Release, une SemaphoreFullException est levée.
Sémaphores nommés
Le système d'exploitation Windows permet aux sémaphores d'avoir des noms. Un sémaphore nommé est à l'échelle du système. Cela signifie qu'une fois que le sémaphore nommé est créé, il est visible pour tous les threads de tous les processus. Ainsi, les sémaphores nommés peuvent être utilisés pour synchroniser les activités de processus ainsi que les threads.
Vous pouvez créer un objet Semaphore représentant un sémaphore système nommé en utilisant l'un des constructeurs qui spécifient un nom.
.gif "Remarque") Remarque : |
|---|
Étant donné que les sémaphores nommés sont à l'échelle du système, il est possible que plusieurs objets Semaphore représentent le même sémaphore nommé. Chaque fois vous appelez un constructeur, ou la méthode OpenExisting, un nouvel objet Semaphore est créé. La spécification du même nom à plusieurs reprises crée différents objets qui représentent le même sémaphore nommé. |
Il est conseillé d'être prudent lors de l'utilisation de sémaphores nommés. Étant donné qu'ils sont à l'échelle du système, un autre processus utilisant le même nom peut entrer dans votre sémaphore de manière inattendue. Un code nuisible en exécution sur le même ordinateur pourrait l'utiliser comme base d'une attaque par déni de service.
Utilisez la sécurité du contrôle d'accès pour protéger un objet Semaphore qui représente un sémaphore nommé, en utilisant de préférence un constructeur qui spécifie un objet SemaphoreSecurity. Vous pouvez également appliquer la sécurité du contrôle d'accès à l'aide de la méthode SetAccessControl, mais la période entre la création du sémaphore et le moment où il est protégé présente des risques. La protection des sémaphores à l'aide de la sécurité du contrôle d'accès empêche les attaques malveillantes, mais ne résout pas le problème des collisions de noms involontaires.