Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

SemaphoreSlim classe

.NET Framework (current version)
 

Date de publication : novembre 2016

Représente une alternative légère à Semaphore qui limite le nombre de threads pouvant accéder simultanément à une ressource ou à un pool de ressources.

Espace de noms:   System.Threading
Assembly:  mscorlib (dans mscorlib.dll)

System.Object
  System.Threading.SemaphoreSlim

[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class SemaphoreSlim : IDisposable

NomDescription
System_CAPS_pubmethodSemaphoreSlim(Int32)

Initialise une nouvelle instance de la classe SemaphoreSlim, en spécifiant le nombre initial de demandes qui peuvent être accordées simultanément.

System_CAPS_pubmethodSemaphoreSlim(Int32, Int32)

Initialise une nouvelle instance de la classe SemaphoreSlim, en spécifiant le nombre initial et le nombre maximal de demandes qui peuvent être accordées simultanément.

NomDescription
System_CAPS_pubpropertyAvailableWaitHandle

Retourne un WaitHandle qui peut être utilisé pour l'attente sur le sémaphore.

System_CAPS_pubpropertyCurrentCount

Obtient le nombre de threads restants qui peuvent accéder à l'objet SemaphoreSlim.

NomDescription
System_CAPS_pubmethodDispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe SemaphoreSlim.

System_CAPS_protmethodDispose(Boolean)

Libère les ressources non managées utilisées par le SemaphoreSlim, et libère éventuellement les ressources managées.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et à exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par une opération garbage collection.(Hérité de Object.)

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_pubmethodRelease()

Libère l'objet SemaphoreSlim une seule fois.

System_CAPS_pubmethodRelease(Int32)

Libère l'objet SemaphoreSlim un nombre de fois déterminé.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodWait()

Bloque le thread actuel jusqu'à ce qu'il puisse accéder à SemaphoreSlim.

System_CAPS_pubmethodWait(CancellationToken)

Bloque le thread actuel jusqu'à ce qu'il puisse accéder à SemaphoreSlim, tout en observant un CancellationToken.

System_CAPS_pubmethodWait(Int32)

Bloque le thread actuel jusqu'à ce qu'il puisse accéder à SemaphoreSlim, à l'aide d'un entier signé 32 bits qui spécifie le délai d'attente.

System_CAPS_pubmethodWait(Int32, CancellationToken)

Bloque le thread actuel jusqu'à ce qu'il puisse accéder à SemaphoreSlim, à l'aide d'un entier signé 32 bits qui spécifie le délai d'attente, tout en observant un CancellationToken.

System_CAPS_pubmethodWait(TimeSpan)

Bloque le thread actuel jusqu'à ce qu'il puisse accéder à SemaphoreSlim, à l'aide d'un TimeSpan pour spécifier le délai d'attente.

System_CAPS_pubmethodWait(TimeSpan, CancellationToken)

Bloque le thread actuel jusqu'à ce qu'il puisse accéder à SemaphoreSlim, à l'aide d'un TimeSpan qui spécifie le délai d'attente, tout en observant un CancellationToken.

System_CAPS_pubmethodWaitAsync()

Attend de façon asynchrone avant d'accéder à SemaphoreSlim.

System_CAPS_pubmethodWaitAsync(CancellationToken)

Attend de façon asynchrone d'accéder à SemaphoreSlim, tout en observant un CancellationToken.

System_CAPS_pubmethodWaitAsync(Int32)

Attend de façon asynchrone d'accéder à SemaphoreSlim, à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps.

System_CAPS_pubmethodWaitAsync(Int32, CancellationToken)

Attend de façon asynchrone d'accéder à SemaphoreSlim, à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps, tout en observant un CancellationToken.

System_CAPS_pubmethodWaitAsync(TimeSpan)

Attend de façon asynchrone d'accéder à SemaphoreSlim, à l'aide d'un TimeSpan pour mesurer l'intervalle de temps.

System_CAPS_pubmethodWaitAsync(TimeSpan, CancellationToken)

Attend de façon asynchrone d'accéder à SemaphoreSlim, à l'aide d'un TimeSpan pour mesurer l'intervalle de temps, tout en observant un CancellationToken.

Les sémaphores sont de deux types : local et système nommé sémaphores. La première est une application locale. Ce dernier est visible dans le système d’exploitation et est approprié pour la synchronisation entre processus. Le SemaphoreSlim est une alternative légère à la Semaphore classe qui n’utilise pas de sémaphores de noyau Windows. Contrairement à la Semaphore (classe), la SemaphoreSlim classe ne prend pas en charge les sémaphores système nommés. Vous pouvez l’utiliser comme un sémaphore local uniquement. La SemaphoreSlim classe est le sémaphore recommandé pour la synchronisation dans une application unique.

Un sémaphore léger contrôle l’accès à un pool de ressources local à votre application. Lorsque vous instanciez un sémaphore, vous pouvez spécifier le nombre maximal de threads qui peuvent accéder au sémaphore simultanément. Vous spécifiez également le nombre initial de threads qui peuvent accéder au sémaphore simultanément. Définit le compteur du sémaphore.

Le compteur est décrémenté à chaque fois qu’un thread entre dans le sémaphore et incrémenté chaque fois qu’un thread libère le sémaphore. Pour entrer dans le sémaphore, un thread appelle l’une de le Wait ou WaitAsync surcharges. Pour libérer le sémaphore, il appelle l’une de le Release surcharges. Lorsque le décompte atteint zéro, les appels suivants à l’un de le Wait méthodes bloquent jusqu'à ce que les autres threads libèrent le sémaphore. Si plusieurs threads sont bloqués, il n’existe aucun ordre garanti, telles que FIFO ou LIFO, qui contrôle lorsque threads entrent dans le sémaphore.

La structure de base pour le code qui utilise un sémaphore pour protéger des ressources est la suivante :


' Enter semaphore by calling one of the Wait or WaitAsync methods.
SemaphoreSlim.Wait()
' 
' Execute code protected by the semaphore. 
'
SemaphoreSlim.Release()

Lorsque tous les threads ont libéré le sémaphore, le nombre est à la valeur maximale spécifié lors de la création du sémaphore. Le compteur du sémaphore est disponible à partir de la CurrentCount propriété.

System_CAPS_importantImportant

La SemaphoreSlim classe n’applique l’identité de thread ou une tâche sur les appels à la Wait, WaitAsync, et Release méthodes. En outre, si le SemaphoreSlim(Int32) constructeur est utilisé pour instancier le SemaphoreSlim objet, le CurrentCount propriété peut augmenter au-delà de la valeur définie par le constructeur. Il est de la responsabilité du programmeur pour vous assurer que les appels à Wait ou WaitAsync méthodes sont appariés correctement avec les appels à Release méthodes.

L’exemple suivant crée un sémaphore avec un nombre maximal de trois threads et un nombre initial de threads de zéro. L’exemple démarre cinq tâches, de bloquer l’exécution pour le sémaphore. Le thread principal appelle la Release(Int32) surcharge pour augmenter le compteur du sémaphore à sa valeur maximale, ce qui permet de trois tâches entrer dans le sémaphore. Chaque fois que le sémaphore est libéré, le compteur du sémaphore précédent est affiché. Console messages suivre l’utilisation sémaphore. L’intervalle de travail simulé augmente légèrement à chaque thread afin de faciliter la lecture de la sortie.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
    private static SemaphoreSlim semaphore;
    // A padding interval to make the output more orderly.
    private static int padding;

    public static void Main()
    {
        // Create the semaphore.
        semaphore = new SemaphoreSlim(0, 3);
        Console.WriteLine("{0} tasks can enter the semaphore.",
                          semaphore.CurrentCount);
        Task[] tasks = new Task[5];

        // Create and start five numbered tasks.
        for(int i = 0; i <= 4; i++)
        {
            tasks[i] = Task.Run( () => {
            // Each task begins by requesting the semaphore.
            Console.WriteLine("Task {0} begins and waits for the semaphore.",
                              Task.CurrentId);
            semaphore.Wait();

            Interlocked.Add(ref padding, 100);

            Console.WriteLine("Task {0} enters the semaphore.", Task.CurrentId);

            // The task just sleeps for 1+ seconds.
            Thread.Sleep(1000 + padding);

            Console.WriteLine("Task {0} releases the semaphore; previous count: {1}.",
                              Task.CurrentId, semaphore.Release()); } );
        }

        // Wait for half a second, to allow all the tasks to start and block.
        Thread.Sleep(500);

        // Restore the semaphore count to its maximum value.
        Console.Write("Main thread calls Release(3) --> ");
        semaphore.Release(3);
        Console.WriteLine("{0} tasks can enter the semaphore.",
                          semaphore.CurrentCount);
        // Main thread waits for the tasks to complete.
        Task.WaitAll(tasks);

        Console.WriteLine("Main thread exits.");
    }
}
// The example displays output like the following:
//       0 tasks can enter the semaphore.
//       Task 1 begins and waits for the semaphore.
//       Task 5 begins and waits for the semaphore.
//       Task 2 begins and waits for the semaphore.
//       Task 4 begins and waits for the semaphore.
//       Task 3 begins and waits for the semaphore.
//       Main thread calls Release(3) --> 3 tasks can enter the semaphore.
//       Task 4 enters the semaphore.
//       Task 1 enters the semaphore.
//       Task 3 enters the semaphore.
//       Task 4 releases the semaphore; previous count: 0.
//       Task 2 enters the semaphore.
//       Task 1 releases the semaphore; previous count: 0.
//       Task 3 releases the semaphore; previous count: 0.
//       Task 5 enters the semaphore.
//       Task 2 releases the semaphore; previous count: 1.
//       Task 5 releases the semaphore; previous count: 2.
//       Main thread exits.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight pour Windows Phone
Disponible depuis 8.0
Windows Phone
Disponible depuis 8.1

Tous les membres publics et protégés de SemaphoreSlim sont thread-safe et peuvent être utilisés simultanément par plusieurs threads, à l’exception de Dispose, qui doit être utilisé uniquement lorsque toutes les autres opérations sur le SemaphoreSlim s’est terminé.

Retour au début
Afficher: