Semaphore Semaphore Semaphore Semaphore Class

Définition

Limite le nombre de threads qui peuvent accéder simultanément à une ressource ou à un pool de ressources.Limits the number of threads that can access a resource or pool of resources concurrently.

public ref class Semaphore sealed : System::Threading::WaitHandle
[System.Runtime.InteropServices.ComVisible(false)]
public sealed class Semaphore : System.Threading.WaitHandle
type Semaphore = class
    inherit WaitHandle
Public NotInheritable Class Semaphore
Inherits WaitHandle
Héritage
Attributs

Exemples

L’exemple de code suivant crée un sémaphore avec un nombre maximal de trois et un nombre initial égal à zéro.The following code example creates a semaphore with a maximum count of three and an initial count of zero. L’exemple démarre cinq threads, qui bloquent l’attente du sémaphore.The example starts five threads, which block waiting for the semaphore. Le thread principal utilise la Release(Int32) surcharge de méthode pour augmenter le nombre de sémaphores à sa valeur maximale, ce qui permet à trois threads d’entrer dans le sémaphore.The main thread uses the Release(Int32) method overload to increase the semaphore count to its maximum, allowing three threads to enter the semaphore. Chaque thread utilise la Thread.Sleep méthode pour attendre une seconde, pour simuler le travail, puis appelle la Release() surcharge de méthode pour libérer le sémaphore.Each thread uses the Thread.Sleep method to wait for one second, to simulate work, and then calls the Release() method overload to release the semaphore. Chaque fois que le sémaphore est libéré, le nombre de sémaphores précédent est affiché.Each time the semaphore is released, the previous semaphore count is displayed. Les messages de la console suivent l’utilisation du sémaphore.Console messages track semaphore use. L’intervalle de travail simulé est légèrement augmenté pour chaque thread, pour faciliter la lecture de la sortie.The simulated work interval is increased slightly for each thread, to make the output easier to read.

#using <System.dll>
using namespace System;
using namespace System::Threading;

public ref class Example
{
private:
   // A semaphore that simulates a limited resource pool.
   //
   static Semaphore^ _pool;

   // A padding interval to make the output more orderly.
   static int _padding;

public:
   static void Main()
   {
      // Create a semaphore that can satisfy up to three
      // concurrent requests. Use an initial count of zero,
      // so that the entire semaphore count is initially
      // owned by the main program thread.
      //
      _pool = gcnew Semaphore( 0,3 );
      
      // Create and start five numbered threads.
      //
      for ( int i = 1; i <= 5; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew ParameterizedThreadStart( Worker ) );
         
         // Start the thread, passing the number.
         //
         t->Start( i );
      }
      
      // Wait for half a second, to allow all the
      // threads to start and to block on the semaphore.
      //
      Thread::Sleep( 500 );
      
      // The main thread starts out holding the entire
      // semaphore count. Calling Release(3) brings the
      // semaphore count back to its maximum value, and
      // allows the waiting threads to enter the semaphore,
      // up to three at a time.
      //
      Console::WriteLine( L"Main thread calls Release(3)." );
      _pool->Release( 3 );

      Console::WriteLine( L"Main thread exits." );
   }

private:
   static void Worker( Object^ num )
   {
      // Each worker thread begins by requesting the
      // semaphore.
      Console::WriteLine( L"Thread {0} begins and waits for the semaphore.", num );
      _pool->WaitOne();
      
      // A padding interval to make the output more orderly.
      int padding = Interlocked::Add( _padding, 100 );

      Console::WriteLine( L"Thread {0} enters the semaphore.", num );
      
      // The thread's "work" consists of sleeping for
      // about a second. Each thread "works" a little
      // longer, just to make the output more orderly.
      //
      Thread::Sleep( 1000 + padding );

      Console::WriteLine( L"Thread {0} releases the semaphore.", num );
      Console::WriteLine( L"Thread {0} previous semaphore count: {1}",
         num, _pool->Release() );
   }
};
using System;
using System.Threading;

public class Example
{
    // A semaphore that simulates a limited resource pool.
    //
    private static Semaphore _pool;

    // A padding interval to make the output more orderly.
    private static int _padding;

    public static void Main()
    {
        // Create a semaphore that can satisfy up to three
        // concurrent requests. Use an initial count of zero,
        // so that the entire semaphore count is initially
        // owned by the main program thread.
        //
        _pool = new Semaphore(0, 3);

        // Create and start five numbered threads. 
        //
        for(int i = 1; i <= 5; i++)
        {
            Thread t = new Thread(new ParameterizedThreadStart(Worker));

            // Start the thread, passing the number.
            //
            t.Start(i);
        }

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

        // The main thread starts out holding the entire
        // semaphore count. Calling Release(3) brings the 
        // semaphore count back to its maximum value, and
        // allows the waiting threads to enter the semaphore,
        // up to three at a time.
        //
        Console.WriteLine("Main thread calls Release(3).");
        _pool.Release(3);

        Console.WriteLine("Main thread exits.");
    }

    private static void Worker(object num)
    {
        // Each worker thread begins by requesting the
        // semaphore.
        Console.WriteLine("Thread {0} begins " +
            "and waits for the semaphore.", num);
        _pool.WaitOne();

        // A padding interval to make the output more orderly.
        int padding = Interlocked.Add(ref _padding, 100);

        Console.WriteLine("Thread {0} enters the semaphore.", num);
        
        // The thread's "work" consists of sleeping for 
        // about a second. Each thread "works" a little 
        // longer, just to make the output more orderly.
        //
        Thread.Sleep(1000 + padding);

        Console.WriteLine("Thread {0} releases the semaphore.", num);
        Console.WriteLine("Thread {0} previous semaphore count: {1}",
            num, _pool.Release());
    }
}
Imports System.Threading

Public Class Example

    ' A semaphore that simulates a limited resource pool.
    '
    Private Shared _pool As Semaphore

    ' A padding interval to make the output more orderly.
    Private Shared _padding As Integer

    <MTAThread> _
    Public Shared Sub Main()
        ' Create a semaphore that can satisfy up to three
        ' concurrent requests. Use an initial count of zero,
        ' so that the entire semaphore count is initially
        ' owned by the main program thread.
        '
        _pool = New Semaphore(0, 3)

        ' Create and start five numbered threads. 
        '
        For i As Integer = 1 To 5
            Dim t As New Thread(New ParameterizedThreadStart(AddressOf Worker))
            'Dim t As New Thread(AddressOf Worker)

            ' Start the thread, passing the number.
            '
            t.Start(i)
        Next i

        ' Wait for half a second, to allow all the
        ' threads to start and to block on the semaphore.
        '
        Thread.Sleep(500)

        ' The main thread starts out holding the entire
        ' semaphore count. Calling Release(3) brings the 
        ' semaphore count back to its maximum value, and
        ' allows the waiting threads to enter the semaphore,
        ' up to three at a time.
        '
        Console.WriteLine("Main thread calls Release(3).")
        _pool.Release(3)

        Console.WriteLine("Main thread exits.")
    End Sub

    Private Shared Sub Worker(ByVal num As Object)
        ' Each worker thread begins by requesting the
        ' semaphore.
        Console.WriteLine("Thread {0} begins " _
            & "and waits for the semaphore.", num)
        _pool.WaitOne()

        ' A padding interval to make the output more orderly.
        Dim padding As Integer = Interlocked.Add(_padding, 100)

        Console.WriteLine("Thread {0} enters the semaphore.", num)
        
        ' The thread's "work" consists of sleeping for 
        ' about a second. Each thread "works" a little 
        ' longer, just to make the output more orderly.
        '
        Thread.Sleep(1000 + padding)

        Console.WriteLine("Thread {0} releases the semaphore.", num)
        Console.WriteLine("Thread {0} previous semaphore count: {1}", _
            num, _
            _pool.Release())
    End Sub
End Class

Remarques

Utilisez la Semaphore classe pour contrôler l’accès à un pool de ressources.Use the Semaphore class to control access to a pool of resources. Les threads entrent dans le sémaphore WaitOne en appelant la méthode, qui est WaitHandle héritée de la classe, et libère le Release sémaphore en appelant la méthode.Threads enter the semaphore by calling the WaitOne method, which is inherited from the WaitHandle class, and release the semaphore by calling the Release method.

Le décompte d’un sémaphore est décrémenté chaque fois qu’un thread entre dans le sémaphore et est incrémenté lorsqu’un thread libère le sémaphore.The count on a semaphore is decremented each time a thread enters the semaphore, and incremented when a thread releases the semaphore. Lorsque le nombre est égal à zéro, les demandes suivantes sont bloquées jusqu’à ce que les autres threads libèrent le sémaphore.When the count is zero, subsequent requests block until other threads release the semaphore. Lorsque tous les threads ont libéré le sémaphore, le nombre est à la valeur maximale spécifiée lors de la création du sémaphore.When all threads have released the semaphore, the count is at the maximum value specified when the semaphore was created.

Il n’existe aucun ordre garanti, tel que FIFO ou LIFO, dans lequel les threads bloqués entrent dans le sémaphore.There is no guaranteed order, such as FIFO or LIFO, in which blocked threads enter the semaphore.

Un thread peut entrer plusieurs fois le sémaphore, en appelant la WaitOne méthode à plusieurs reprises.A thread can enter the semaphore multiple times, by calling the WaitOne method repeatedly. Pour libérer une partie ou la totalité de ces entrées, le thread peut appeler plusieurs Release() fois la surcharge de méthode sans paramètre, ou elle Release(Int32) peut appeler la surcharge de méthode qui spécifie le nombre d’entrées à libérer.To release some or all of these entries, the thread can call the parameterless Release() method overload multiple times, or it can call the Release(Int32) method overload that specifies the number of entries to be released.

La Semaphore classe n’applique pas l’identité des threads WaitOne aux Releaseappels à ou.The Semaphore class does not enforce thread identity on calls to WaitOne or Release. Il incombe au programmeur de s’assurer que les threads ne libèrent pas le sémaphore trop souvent.It is the programmer's responsibility to ensure that threads do not release the semaphore too many times. Supposons, par exemple, qu'un sémaphore ait un nombre maximal égal à deux et que le thread A et le thread B entrent dans le sémaphore.For example, suppose a semaphore has a maximum count of two, and that thread A and thread B both enter the semaphore. Si une erreur de programmation dans le thread B la force Release à appeler deux fois, les deux appels sont correctement effectués.If a programming error in thread B causes it to call Release twice, both calls succeed. Le nombre maximal du sémaphore sera alors atteint, et quand le thread A appellera Release, une exception SemaphoreFullException sera levée.The count on the semaphore is full, and when thread A eventually calls Release, a SemaphoreFullException is thrown.

Les sémaphores sont de deux types : les sémaphores locaux et les sémaphores système nommés.Semaphores are of two types: local semaphores and named system semaphores. Si vous créez un Semaphore objet à l’aide d’un constructeur qui accepte un nom, il est associé à un sémaphore de système d’exploitation de ce nom.If you create a Semaphore object using a constructor that accepts a name, it is associated with an operating-system semaphore of that name. Les sémaphores système nommés sont visibles dans tout le système d’exploitation et peuvent être utilisés pour synchroniser les activités des processus.Named system semaphores are visible throughout the operating system, and can be used to synchronize the activities of processes. Vous pouvez créer plusieurs Semaphore objets qui représentent le même sémaphore système nommé, et vous pouvez utiliser la OpenExisting méthode pour ouvrir un sémaphore système nommé existant.You can create multiple Semaphore objects that represent the same named system semaphore, and you can use the OpenExisting method to open an existing named system semaphore.

Un sémaphore local existe uniquement dans votre processus.A local semaphore exists only within your process. Il peut être utilisé par tout thread de votre processus qui a une référence à l’objet Semaphore local.It can be used by any thread in your process that has a reference to the local Semaphore object. Chaque Semaphore objet est un sémaphore local distinct.Each Semaphore object is a separate local semaphore.

Constructeurs

Semaphore(Int32, Int32) Semaphore(Int32, Int32) Semaphore(Int32, Int32) Semaphore(Int32, Int32)

Initialise une nouvelle instance de la classe Semaphore en spécifiant le nombre initial d’entrées et le nombre maximal d’entrées simultanées.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries.

Semaphore(Int32, Int32, String) Semaphore(Int32, Int32, String) Semaphore(Int32, Int32, String) Semaphore(Int32, Int32, String)

Initialise une nouvelle instance de la classe Semaphore en spécifiant le nombre initial d’entrées et le nombre maximal d’entrées simultanées, et en spécifiant en option le nom d’un objet sémaphore système.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries, and optionally specifying the name of a system semaphore object.

Semaphore(Int32, Int32, String, Boolean) Semaphore(Int32, Int32, String, Boolean) Semaphore(Int32, Int32, String, Boolean) Semaphore(Int32, Int32, String, Boolean)

Initialise une nouvelle instance de la classe Semaphore en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées, en spécifiant en option le nom d'un objet sémaphore système et en spécifiant une variable qui reçoit une valeur indiquant si un sémaphore système a été créé.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries, optionally specifying the name of a system semaphore object, and specifying a variable that receives a value indicating whether a new system semaphore was created.

Semaphore(Int32, Int32, String, Boolean, SemaphoreSecurity) Semaphore(Int32, Int32, String, Boolean, SemaphoreSecurity) Semaphore(Int32, Int32, String, Boolean, SemaphoreSecurity) Semaphore(Int32, Int32, String, Boolean, SemaphoreSecurity)

Initialise une nouvelle instance de la classe Semaphore en spécifiant le nombre initial d'entrées et le nombre maximal d'entrées simultanées, en spécifiant en option le nom d'un objet sémaphore système et en spécifiant une variable qui reçoit une valeur indiquant si un nouveau sémaphore système a été créé et spécifiant le contrôle d'accès de sécurité pour le sémaphore système.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries, optionally specifying the name of a system semaphore object, specifying a variable that receives a value indicating whether a new system semaphore was created, and specifying security access control for the system semaphore.

Méthodes

Close() Close() Close() Close()

Libère toutes les ressources détenues par le WaitHandle actuel.Releases all resources held by the current WaitHandle.

(Inherited from WaitHandle)
CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Inherited from WaitHandle)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

En cas de substitution dans une classe dérivée, libère les ressources non managées utilisées par WaitHandle et libère éventuellement les ressources managées.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Inherited from WaitHandle)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetAccessControl() GetAccessControl() GetAccessControl() GetAccessControl()

Reçoit la sécurité de contrôle d'accès pour un sémaphore système nommé.Gets the access control security for a named system semaphore.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
OpenExisting(String) OpenExisting(String) OpenExisting(String) OpenExisting(String)

Ouvre le sémaphore nommé spécifié s'il existe déjà.Opens the specified named semaphore, if it already exists.

OpenExisting(String, SemaphoreRights) OpenExisting(String, SemaphoreRights) OpenExisting(String, SemaphoreRights) OpenExisting(String, SemaphoreRights)

Ouvre le sémaphore nommé spécifié, s'il existe déjà, avec l'accès de sécurité souhaité.Opens the specified named semaphore, if it already exists, with the desired security access.

Release() Release() Release() Release()

Quitte le sémaphore et retourne le compteur antérieur.Exits the semaphore and returns the previous count.

Release(Int32) Release(Int32) Release(Int32) Release(Int32)

Quitte le sémaphore un nombre spécifié de fois et retourne le compteur précédent.Exits the semaphore a specified number of times and returns the previous count.

SetAccessControl(SemaphoreSecurity) SetAccessControl(SemaphoreSecurity) SetAccessControl(SemaphoreSecurity) SetAccessControl(SemaphoreSecurity)

Définit la sécurité de contrôle d'accès pour un sémaphore système nommé.Sets the access control security for a named system semaphore.

ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)
TryOpenExisting(String, Semaphore) TryOpenExisting(String, Semaphore) TryOpenExisting(String, Semaphore) TryOpenExisting(String, Semaphore)

Ouvre le sémaphore nommé spécifié, s'il existe déjà, et retourne une valeur indiquant si l'opération a réussi.Opens the specified named semaphore, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, SemaphoreRights, Semaphore) TryOpenExisting(String, SemaphoreRights, Semaphore) TryOpenExisting(String, SemaphoreRights, Semaphore) TryOpenExisting(String, SemaphoreRights, Semaphore)

Ouvre le sémaphore nommé spécifié, s'il existe déjà, avec l'accès de sécurité souhaité, puis retourne une valeur indiquant si l'opération a réussi.Opens the specified named semaphore, if it already exists, with the desired security access, and returns a value that indicates whether the operation succeeded.

WaitOne() WaitOne() WaitOne() WaitOne()

Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal.Blocks the current thread until the current WaitHandle receives a signal.

(Inherited from WaitHandle)
WaitOne(Int32) WaitOne(Int32) WaitOne(Int32) WaitOne(Int32)

Bloque le thread actuel jusqu'à ce que le WaitHandle actuel reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l'intervalle de temps.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Inherited from WaitHandle)
WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean)

Bloque le thread actuel jusqu’à ce que le WaitHandle actuel reçoive un signal, en utilisant un entier signé 32 bits pour spécifier l’intervalle de temps et en spécifiant s’il faut quitter le domaine de synchronisation avant l’attente.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Inherited from WaitHandle)
WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan)

Bloque le thread actuel jusqu'à ce que l'instance actuelle reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Inherited from WaitHandle)
WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean)

Bloque le thread actuel jusqu'à ce que l'instance actuelle reçoive un signal, en utilisant une valeur TimeSpan pour spécifier l'intervalle de temps et en spécifiant s'il faut quitter le domaine de synchronisation avant l'attente.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Inherited from WaitHandle)

Propriétés

Handle Handle Handle Handle

Obtient ou définit le handle du système d'exploitation natif.Gets or sets the native operating system handle.

(Inherited from WaitHandle)
SafeWaitHandle SafeWaitHandle SafeWaitHandle SafeWaitHandle

Obtient ou définit le handle du système d'exploitation natif.Gets or sets the native operating system handle.

(Inherited from WaitHandle)

Implémentations d’interfaces explicites

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Libère toutes les ressources utilisées par WaitHandle.Releases all resources used by the WaitHandle.

(Inherited from WaitHandle)

Champs

WaitTimeout WaitTimeout WaitTimeout WaitTimeout

Indique que le délai fixé pour une opération WaitAny(WaitHandle[], Int32, Boolean) a été dépassé sans qu'aucun des handles d'attente n'ait été signalé.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Ce champ est constant.This field is constant.

(Inherited from WaitHandle)

Méthodes d’extension

GetAccessControl(Semaphore) GetAccessControl(Semaphore) GetAccessControl(Semaphore) GetAccessControl(Semaphore)
SetAccessControl(Semaphore, SemaphoreSecurity) SetAccessControl(Semaphore, SemaphoreSecurity) SetAccessControl(Semaphore, SemaphoreSecurity) SetAccessControl(Semaphore, SemaphoreSecurity)
GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle)

Obtient le handle sécurisé pour un handle d’attente de système d’exploitation natif.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Définit un handle sécurisé pour un handle d’attente de système d’exploitation natif.Sets a safe handle for a native operating system wait handle.

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi