Semaphore Constructeurs

Définition

Espace de noms:

System.Threading

Assembly:

System.Threading.dll

Initialise une nouvelle instance de la classe Semaphore.

Surcharges

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.
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.
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éé.

Semaphore(Int32, Int32)

Source:

Semaphore.cs

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.

public:
 Semaphore(int initialCount, int maximumCount);

public Semaphore (int initialCount, int maximumCount);

new System.Threading.Semaphore : int * int -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer)

Paramètres

initialCount

Int32

Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément.

maximumCount

Int32

Nombre maximal de demandes pour le sémaphore qui peut être accordé simultanément.

Exceptions

ArgumentException

initialCount est supérieur à maximumCount.

ArgumentOutOfRangeException

maximumCount est inférieur à 1.

- ou -

initialCount est inférieur à 0.

Exemples

L’exemple suivant crée un sémaphore avec un nombre maximal de trois et un nombre initial de zéro. L’exemple démarre cinq threads, qui bloquent l’attente du sémaphore. Le thread main utilise la Release(Int32) surcharge de méthode pour augmenter le nombre de sémaphores à son maximum, ce qui permet à trois threads d’entrer dans le sémaphore. Chaque thread utilise la Thread.Sleep méthode pour attendre une seconde, simuler le travail, puis appelle la surcharge de méthode Release() pour libérer le sémaphore. Chaque fois que le sémaphore est libéré, le nombre de sémaphores précédent est affiché. Les messages de console suivent l’utilisation du sémaphore. L’intervalle de travail simulé est légèrement augmenté pour chaque thread, afin de faciliter la lecture de la sortie.

#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(initialCount: 0, maximumCount: 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(releaseCount: 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

Ce constructeur initialise un sémaphore sans nom. Tous les threads qui utilisent une instance d’un tel sémaphore doivent avoir des références au instance.

Si initialCount est inférieur à maximumCount, l’effet est le même que si le thread actuel avait appelé WaitOne (maximumCount moins initialCount) fois. Si vous ne souhaitez pas réserver d’entrées pour le thread qui crée le sémaphore, utilisez le même nombre pour maximumCount et initialCount.

Voir aussi

• Threading managé
• Semaphore

Semaphore(Int32, Int32, String)

Source:

Semaphore.cs

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.

public:
 Semaphore(int initialCount, int maximumCount, System::String ^ name);

public Semaphore (int initialCount, int maximumCount, string? name);

new System.Threading.Semaphore : int * int * string -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer, name As String)

Paramètres

initialCount

Int32

Nombre initial de demandes pour le sémaphore qui peuvent être accordées simultanément.

maximumCount

Int32

Nombre maximal de demandes pour le sémaphore qui peut être accordé simultanément.

name

String

Nom, si l’événement doit être partagé avec d’autres processus ; sinon, null ou une chaîne vide. Le nom respecte la casse. Le caractère de barre oblique inverse (\) est réservé et ne peut être utilisé que pour spécifier un espace de noms. Pour plus d’informations sur les espaces de noms, consultez la section remarques. Il peut y avoir d’autres restrictions sur le nom en fonction du système d’exploitation. Par exemple, sur les systèmes d’exploitation Unix, le nom après l’exclusion de l’espace de noms doit être un nom de fichier valide.

Exceptions

ArgumentException

initialCount est supérieur à maximumCount.

- ou -

.NET Framework uniquement : name est plus long que MAX_PATH (260 caractères).

ArgumentOutOfRangeException

maximumCount est inférieur à 1.

- ou -

initialCount est inférieur à 0.

IOException

name n'est pas valide. Il peut y avoir diverses raisons à cela, notamment des restrictions placées par le système d’exploitation (par exemple, un préfixe inconnu ou des caractères non valides). Notez que le nom et les préfixes communs « Global\ » et « Local\ » respectent la casse.

- ou -

Il y a eu une autre erreur. La propriété HResult est susceptible de fournir plus d’informations.

DirectoryNotFoundException

Windows uniquement : name a spécifié un espace de noms inconnu. Pour plus d’informations, consultez Noms d’objets.

PathTooLongException

name est trop long. Les restrictions de longueur peuvent dépendre du système d’exploitation ou de la configuration.

UnauthorizedAccessException

Le sémaphore nommé existe et a la sécurité de contrôle d’accès, et l’utilisateur n’a pas FullControl.

WaitHandleCannotBeOpenedException

Il n’est pas possible de créer un objet de synchronisation portant le name fourni. Il est possible qu’un objet de synchronisation d’un autre type possède le même nom.

Exemples

L’exemple de code suivant illustre le comportement inter-processus d’un sémaphore nommé. L’exemple crée un sémaphore nommé avec un nombre maximal de cinq et un nombre initial de cinq. Le programme effectue trois appels à la WaitOne méthode . Par conséquent, si vous exécutez l’exemple compilé à partir de deux fenêtres de commande, la deuxième copie sera bloquée lors du troisième appel à WaitOne. Relâchez une ou plusieurs entrées dans la première copie du programme pour débloquer la deuxième.

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

public ref class Example
{
public:
   static void main()
   {
      // Create a Semaphore object that represents the named
      // system semaphore "SemaphoreExample3". The semaphore has a
      // maximum count of five. The initial count is also five.
      // There is no point in using a smaller initial count,
      // because the initial count is not used if this program
      // doesn't create the named system semaphore, and with
      // this method overload there is no way to tell. Thus, this
      // program assumes that it is competing with other
      // programs for the semaphore.
      //
      Semaphore^ sem = gcnew Semaphore( 5,5,L"SemaphoreExample3" );
      
      // Attempt to enter the semaphore three times. If another
      // copy of this program is already running, only the first
      // two requests can be satisfied. The third blocks. Note
      // that in a real application, timeouts should be used
      // on the WaitOne calls, to avoid deadlocks.
      //
      sem->WaitOne();
      Console::WriteLine( L"Entered the semaphore once." );
      sem->WaitOne();
      Console::WriteLine( L"Entered the semaphore twice." );
      sem->WaitOne();
      Console::WriteLine( L"Entered the semaphore three times." );
      
      // The thread executing this program has entered the
      // semaphore three times. If a second copy of the program
      // is run, it will block until this program releases the
      // semaphore at least once.
      //
      Console::WriteLine( L"Enter the number of times to call Release." );
      int n;
      if ( Int32::TryParse( Console::ReadLine(),n ) )
      {
         sem->Release( n );
      }

      int remaining = 3 - n;
      if ( remaining > 0 )
      {
         Console::WriteLine( L"Press Enter to release the remaining "
         L"count ({0}) and exit the program.", remaining );
         Console::ReadLine();
         sem->Release( remaining );
      }
   }
};

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        // Create a Semaphore object that represents the named 
        // system semaphore "SemaphoreExample3". The semaphore has a
        // maximum count of five. The initial count is also five. 
        // There is no point in using a smaller initial count,
        // because the initial count is not used if this program
        // doesn't create the named system semaphore, and with 
        // this method overload there is no way to tell. Thus, this
        // program assumes that it is competing with other
        // programs for the semaphore.
        //
        Semaphore sem = new Semaphore(5, 5, "SemaphoreExample3");

        // Attempt to enter the semaphore three times. If another 
        // copy of this program is already running, only the first
        // two requests can be satisfied. The third blocks. Note 
        // that in a real application, timeouts should be used
        // on the WaitOne calls, to avoid deadlocks.
        //
        sem.WaitOne();
        Console.WriteLine("Entered the semaphore once.");
        sem.WaitOne();
        Console.WriteLine("Entered the semaphore twice.");
        sem.WaitOne();
        Console.WriteLine("Entered the semaphore three times.");

        // The thread executing this program has entered the 
        // semaphore three times. If a second copy of the program
        // is run, it will block until this program releases the 
        // semaphore at least once.
        //
        Console.WriteLine("Enter the number of times to call Release.");
        int n;
        if (int.TryParse(Console.ReadLine(), out n))
        {
            sem.Release(n);
        }

        int remaining = 3 - n;
        if (remaining > 0)
        {
            Console.WriteLine("Press Enter to release the remaining " +
                "count ({0}) and exit the program.", remaining);
            Console.ReadLine();
            sem.Release(remaining);
        }
    }
}

Imports System.Threading

Public Class Example

    <MTAThread> _
    Public Shared Sub Main()
        ' Create a Semaphore object that represents the named 
        ' system semaphore "SemaphoreExample3". The semaphore has a
        ' maximum count of five. The initial count is also five. 
        ' There is no point in using a smaller initial count,
        ' because the initial count is not used if this program
        ' doesn't create the named system semaphore, and with 
        ' this method overload there is no way to tell. Thus, this
        ' program assumes that it is competing with other
        ' programs for the semaphore.
        '
        Dim sem As New Semaphore(5, 5, "SemaphoreExample3")

        ' Attempt to enter the semaphore three times. If another 
        ' copy of this program is already running, only the first
        ' two requests can be satisfied. The third blocks. Note 
        ' that in a real application, timeouts should be used
        ' on the WaitOne calls, to avoid deadlocks.
        '
        sem.WaitOne()
        Console.WriteLine("Entered the semaphore once.")
        sem.WaitOne()
        Console.WriteLine("Entered the semaphore twice.")
        sem.WaitOne()
        Console.WriteLine("Entered the semaphore three times.")

        ' The thread executing this program has entered the 
        ' semaphore three times. If a second copy of the program
        ' is run, it will block until this program releases the 
        ' semaphore at least once.
        '
        Console.WriteLine("Enter the number of times to call Release.")
        Dim n As Integer
        If Integer.TryParse(Console.ReadLine(), n) Then
            sem.Release(n)
        End If

        Dim remaining As Integer = 3 - n
        If (remaining) > 0 Then
            Console.WriteLine("Press Enter to release the remaining " _
                & "count ({0}) and exit the program.", remaining)
            Console.ReadLine()
            sem.Release(remaining)
        End If

    End Sub 
End Class

Remarques

Ce constructeur initialise un Semaphore objet qui représente un sémaphore système nommé. Vous pouvez créer plusieurs Semaphore objets qui représentent le même sémaphore système nommé.

Le name peut être préfixé avec Global\ ou Local\ pour spécifier un espace de noms. Lorsque l’espace Global de noms est spécifié, l’objet de synchronisation peut être partagé avec n’importe quel processus sur le système. Lorsque l’espace Local de noms est spécifié, qui est également la valeur par défaut lorsqu’aucun espace de noms n’est spécifié, l’objet de synchronisation peut être partagé avec des processus dans la même session. Sur Windows, une session est une session de connexion et les services s’exécutent généralement dans une autre session non interactive. Sur les systèmes d’exploitation de type Unix, chaque interpréteur de commandes a sa propre session. Les objets de synchronisation locale de session peuvent convenir à la synchronisation entre des processus avec une relation parent/enfant où ils s’exécutent tous dans la même session. Pour plus d’informations sur les noms d’objets de synchronisation sur Windows, consultez Noms d’objets.

Si un name est fourni et qu’un objet de synchronisation du type demandé existe déjà dans l’espace de noms, l’objet de synchronisation existant est utilisé. Si un objet de synchronisation d’un autre type existe déjà dans l’espace de noms, un WaitHandleCannotBeOpenedException est levée. Sinon, un nouvel objet de synchronisation est créé.

Si le sémaphore système nommé n’existe pas, il est créé avec le nombre initial et le nombre maximal spécifiés par initialCount et maximumCount. Si le sémaphore système nommé existe déjà et maximumCount ne sont pas utilisés, initialCount bien que des valeurs non valides provoquent toujours des exceptions. Si vous devez déterminer si un sémaphore système nommé a été créé ou non, utilisez plutôt la surcharge du Semaphore(Int32, Int32, String, Boolean) constructeur.

Important

Lorsque vous utilisez cette surcharge de constructeur, la pratique recommandée consiste à spécifier le même nombre pour initialCount et maximumCount. Si initialCount est inférieur à maximumCount, et qu’un sémaphore système nommé est créé, l’effet est le même que si le thread actuel avait appelé WaitOne (maximumCount moins initialCount) heures. Toutefois, avec cette surcharge de constructeur, il n’existe aucun moyen de déterminer si un sémaphore système nommé a été créé.

Si vous spécifiez null ou une chaîne vide pour name, un sémaphore local est créé, comme si vous aviez appelé la surcharge du Semaphore(Int32, Int32) constructeur.

Étant donné que les sémaphores nommés sont visibles dans tout le système d’exploitation, ils peuvent être utilisés pour coordonner l’utilisation des ressources au-delà des limites du processus.

Si vous souhaitez savoir s’il existe un sémaphore système nommé, utilisez la OpenExisting méthode . La OpenExisting méthode tente d’ouvrir un sémaphore nommé existant et lève une exception si le sémaphore système n’existe pas.

Attention

Par défaut, un sémaphore nommé n’est pas limité à l’utilisateur qui l’a créé. D’autres utilisateurs peuvent être en mesure d’ouvrir et d’utiliser le sémaphore, notamment en interférant avec le sémaphore en acquérant le sémaphore plusieurs fois et en ne le libérant pas. Pour restreindre l’accès à des utilisateurs spécifiques, vous pouvez utiliser une surcharge de constructeur ou SemaphoreAcl passer un SemaphoreSecurity lors de la création du sémaphore nommé. Évitez d’utiliser des sémaphores nommés sans restrictions d’accès sur les systèmes qui peuvent avoir des utilisateurs non approuvés exécutant du code.

Voir aussi

• Threading managé
• Semaphore

Semaphore(Int32, Int32, String, Boolean)

Source:

Semaphore.cs

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éé.

public:
 Semaphore(int initialCount, int maximumCount, System::String ^ name, [Runtime::InteropServices::Out] bool % createdNew);

public Semaphore (int initialCount, int maximumCount, string? name, out bool createdNew);

new System.Threading.Semaphore : int * int * string * bool -> System.Threading.Semaphore

Public Sub New (initialCount As Integer, maximumCount As Integer, name As String, ByRef createdNew As Boolean)

Paramètres

initialCount

Int32

Nombre initial de demandes pour le sémaphore qui peut être satisfait simultanément.

maximumCount

Int32

Nombre maximal de demandes pour le sémaphore qui peut être satisfait simultanément.

name

String

Nom, si l’événement doit être partagé avec d’autres processus ; sinon, null ou une chaîne vide. Le nom respecte la casse. Le caractère de barre oblique inverse (\) est réservé et ne peut être utilisé que pour spécifier un espace de noms. Pour plus d’informations sur les espaces de noms, consultez la section remarques. Il peut y avoir d’autres restrictions sur le nom en fonction du système d’exploitation. Par exemple, sur les systèmes d’exploitation Unix, le nom après l’exclusion de l’espace de noms doit être un nom de fichier valide.

createdNew

Boolean

Cette méthode retourne true si un sémaphore local a été créé (en d'autres termes, si name est null ou une chaîne vide) ou si le sémaphore système nommé spécifié a été créé ; false si le sémaphore système nommé spécifié existait déjà. Ce paramètre est passé sans être initialisé.

Exceptions

ArgumentException

initialCount est supérieur à maximumCount.

- ou -

.NET Framework uniquement : name est plus long que MAX_PATH (260 caractères).

ArgumentOutOfRangeException

maximumCount est inférieur à 1.

- ou -

initialCount est inférieur à 0.

IOException

name n'est pas valide. Il peut y avoir diverses raisons à cela, notamment des restrictions placées par le système d’exploitation (par exemple, un préfixe inconnu ou des caractères non valides). Notez que le nom et les préfixes communs « Global\ » et « Local\ » respectent la casse.

- ou -

Il y a eu une autre erreur. La propriété HResult est susceptible de fournir plus d’informations.

DirectoryNotFoundException

Windows uniquement : name a spécifié un espace de noms inconnu. Pour plus d’informations, consultez Noms d’objets.

PathTooLongException

name est trop long. Les restrictions de longueur peuvent dépendre du système d’exploitation ou de la configuration.

UnauthorizedAccessException

Le sémaphore nommé existe et a la sécurité de contrôle d’accès, et l’utilisateur n’a pas FullControl.

WaitHandleCannotBeOpenedException

Il n’est pas possible de créer un objet de synchronisation portant le name fourni. Il est possible qu’un objet de synchronisation d’un autre type possède le même nom.

Exemples

L’exemple de code suivant illustre le comportement inter-processus d’un sémaphore nommé. L’exemple crée un sémaphore nommé avec un nombre maximal de cinq et un nombre initial de deux. Autrement dit, il réserve trois entrées pour le thread qui appelle le constructeur. Si createNew a la valeur false, le programme effectue trois appels à la WaitOne méthode . Par conséquent, si vous exécutez l’exemple compilé à partir de deux fenêtres de commande, la deuxième copie sera bloquée lors du troisième appel à WaitOne. Relâchez une ou plusieurs entrées dans la première copie du programme pour débloquer la deuxième.

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

public ref class Example
{
public:
   static void main()
   {
      // The value of this variable is set by the semaphore
      // constructor. It is true if the named system semaphore was
      // created, and false if the named semaphore already existed.
      //
      bool semaphoreWasCreated;
      
      // Create a Semaphore object that represents the named
      // system semaphore "SemaphoreExample". The semaphore has a
      // maximum count of five, and an initial count of two. The
      // Boolean value that indicates creation of the underlying
      // system object is placed in semaphoreWasCreated.
      //
      Semaphore^ sem = gcnew Semaphore( 2,5,L"SemaphoreExample",
         semaphoreWasCreated );
      if ( semaphoreWasCreated )
      {
         // If the named system semaphore was created, its count is
         // set to the initial count requested in the constructor.
         // In effect, the current thread has entered the semaphore
         // three times.
         //
         Console::WriteLine( L"Entered the semaphore three times." );
      }
      else
      {
         // If the named system semaphore was not created,
         // attempt to enter it three times. If another copy of
         // this program is already running, only the first two
         // requests can be satisfied. The third blocks.
         //
         sem->WaitOne();
         Console::WriteLine( L"Entered the semaphore once." );
         sem->WaitOne();
         Console::WriteLine( L"Entered the semaphore twice." );
         sem->WaitOne();
         Console::WriteLine( L"Entered the semaphore three times." );
      }
      
      // The thread executing this program has entered the
      // semaphore three times. If a second copy of the program
      // is run, it will block until this program releases the
      // semaphore at least once.
      //
      Console::WriteLine( L"Enter the number of times to call Release." );
      int n;
      if ( Int32::TryParse( Console::ReadLine(), n ) )
      {
         sem->Release( n );
      }

      int remaining = 3 - n;
      if ( remaining > 0 )
      {
         Console::WriteLine( L"Press Enter to release the remaining "
         L"count ({0}) and exit the program.", remaining );
         Console::ReadLine();
         sem->Release( remaining );
      }
   }
};

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        // The value of this variable is set by the semaphore
        // constructor. It is true if the named system semaphore was
        // created, and false if the named semaphore already existed.
        //
        bool semaphoreWasCreated;

        // Create a Semaphore object that represents the named 
        // system semaphore "SemaphoreExample". The semaphore has a
        // maximum count of five, and an initial count of two. The
        // Boolean value that indicates creation of the underlying 
        // system object is placed in semaphoreWasCreated.
        //
        Semaphore sem = new Semaphore(2, 5, "SemaphoreExample", 
            out semaphoreWasCreated);

        if (semaphoreWasCreated)
        {
            // If the named system semaphore was created, its count is
            // set to the initial count requested in the constructor.
            // In effect, the current thread has entered the semaphore
            // three times.
            // 
            Console.WriteLine("Entered the semaphore three times.");
        }
        else
        {      
            // If the named system semaphore was not created,  
            // attempt to enter it three times. If another copy of
            // this program is already running, only the first two
            // requests can be satisfied. The third blocks.
            //
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore once.");
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore twice.");
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore three times.");
        }

        // The thread executing this program has entered the 
        // semaphore three times. If a second copy of the program
        // is run, it will block until this program releases the 
        // semaphore at least once.
        //
        Console.WriteLine("Enter the number of times to call Release.");
        int n;
        if (int.TryParse(Console.ReadLine(), out n))
        {
            sem.Release(n);
        }

        int remaining = 3 - n;
        if (remaining > 0)
        {
            Console.WriteLine("Press Enter to release the remaining " +
                "count ({0}) and exit the program.", remaining);
            Console.ReadLine();
            sem.Release(remaining);
        }
    } 
}

Imports System.Threading

Public Class Example

    <MTAThread> _
    Public Shared Sub Main()
        ' The value of this variable is set by the semaphore
        ' constructor. It is True if the named system semaphore was
        ' created, and False if the named semaphore already existed.
        '
        Dim semaphoreWasCreated As Boolean

        ' Create a Semaphore object that represents the named 
        ' system semaphore "SemaphoreExample". The semaphore has a
        ' maximum count of five, and an initial count of two. The
        ' Boolean value that indicates creation of the underlying 
        ' system object is placed in semaphoreWasCreated.
        '
        Dim sem As New Semaphore(2, 5, "SemaphoreExample", _
            semaphoreWasCreated)

        If semaphoreWasCreated Then
            ' If the named system semaphore was created, its count is
            ' set to the initial count requested in the constructor.
            ' In effect, the current thread has entered the semaphore
            ' three times.
            ' 
            Console.WriteLine("Entered the semaphore three times.")
        Else
            ' If the named system semaphore was not created,  
            ' attempt to enter it three times. If another copy of
            ' this program is already running, only the first two
            ' requests can be satisfied. The third blocks.
            '
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore once.")
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore twice.")
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore three times.")
        End If

        ' The thread executing this program has entered the 
        ' semaphore three times. If a second copy of the program
        ' is run, it will block until this program releases the 
        ' semaphore at least once.
        '
        Console.WriteLine("Enter the number of times to call Release.")
        Dim n As Integer
        If Integer.TryParse(Console.ReadLine(), n) Then
            sem.Release(n)
        End If

        Dim remaining As Integer = 3 - n
        If (remaining) > 0 Then
            Console.WriteLine("Press Enter to release the remaining " _
                & "count ({0}) and exit the program.", remaining)
            Console.ReadLine()
            sem.Release(remaining)
        End If

    End Sub 
End Class

Remarques

Le name peut être préfixé avec Global\ ou Local\ pour spécifier un espace de noms. Lorsque l’espace Global de noms est spécifié, l’objet de synchronisation peut être partagé avec n’importe quel processus sur le système. Lorsque l’espace Local de noms est spécifié, qui est également la valeur par défaut lorsqu’aucun espace de noms n’est spécifié, l’objet de synchronisation peut être partagé avec des processus dans la même session. Sur Windows, une session est une session de connexion et les services s’exécutent généralement dans une autre session non interactive. Sur les systèmes d’exploitation de type Unix, chaque interpréteur de commandes a sa propre session. Les objets de synchronisation locale de session peuvent convenir à la synchronisation entre des processus avec une relation parent/enfant où ils s’exécutent tous dans la même session. Pour plus d’informations sur les noms d’objets de synchronisation sur Windows, consultez Noms d’objets.

Si un name est fourni et qu’un objet de synchronisation du type demandé existe déjà dans l’espace de noms, l’objet de synchronisation existant est utilisé. Si un objet de synchronisation d’un autre type existe déjà dans l’espace de noms, un WaitHandleCannotBeOpenedException est levée. Sinon, un nouvel objet de synchronisation est créé.

Ce constructeur initialise un Semaphore objet qui représente un sémaphore système nommé. Vous pouvez créer plusieurs Semaphore objets qui représentent le même sémaphore système nommé.

Si le sémaphore système nommé n’existe pas, il est créé avec le nombre initial et le nombre maximal spécifiés par initialCount et maximumCount. Si le sémaphore système nommé existe déjà et maximumCount ne sont pas utilisés, initialCount bien que des valeurs non valides provoquent toujours des exceptions. Utilisez createdNew pour déterminer si le sémaphore système a été créé.

Si initialCount est inférieur à maximumCount, et createdNew est true, l’effet est le même que si le thread actuel avait appelé WaitOne (maximumCount moins initialCount) fois.

Si vous spécifiez null ou une chaîne vide pour name, un sémaphore local est créé, comme si vous aviez appelé la surcharge du Semaphore(Int32, Int32) constructeur. Dans ce cas, createdNew est toujours true.

Étant donné que les sémaphores nommés sont visibles dans tout le système d’exploitation, ils peuvent être utilisés pour coordonner l’utilisation des ressources au-delà des limites du processus.

Attention

Par défaut, un sémaphore nommé n’est pas limité à l’utilisateur qui l’a créé. D’autres utilisateurs peuvent être en mesure d’ouvrir et d’utiliser le sémaphore, notamment en interférant avec le sémaphore en acquérant le sémaphore plusieurs fois et en ne le libérant pas. Pour restreindre l’accès à des utilisateurs spécifiques, vous pouvez utiliser une surcharge de constructeur ou SemaphoreAcl passer un SemaphoreSecurity lors de la création du sémaphore nommé. Évitez d’utiliser des sémaphores nommés sans restrictions d’accès sur les systèmes qui peuvent avoir des utilisateurs non approuvés exécutant du code.

Voir aussi

• Threading managé
• Semaphore