Semaphore Constructeurs

Source:

Semaphore.cs

Source:

Semaphore.cs

Source:

Semaphore.cs

Source:

Semaphore.cs

Source:

Semaphore.cs

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

Exceptions

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, ce qui bloque l’attente du sémaphore. Le thread principal utilise la Release(Int32) surcharge de méthode pour augmenter le nombre de sémaphores au maximum, ce qui permet à trois threads d’entrer dans le sémaphore. Chaque thread utilise la méthode pour attendre une seconde, pour simuler le Thread.Sleep travail, puis appelle la Release() surcharge de méthode pour libérer le sémaphore. Chaque fois que le sémaphore est libéré, le nombre de sémaphores précédents s’affiche. 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;
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 de ce sémaphore doivent avoir des références à l’instance.

S’il 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é
• Sémaphore

Source:

Semaphore.cs

Source:

Semaphore.cs

Source:

Semaphore.cs

Source:

Semaphore.cs

Source:

Semaphore.cs

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

public Semaphore(int initialCount, int maximumCount, 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

Exceptions

Exemples

L’exemple de code suivant illustre le comportement interprocesseur 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 bloque le troisième appel à WaitOne. Relâchez une ou plusieurs entrées dans la première copie du programme pour débloquer la seconde.

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

Il name peut être préfixé Global\ ou Local\ spécifier un espace de noms. Lorsque l’espace Global de noms est spécifié, l’objet de synchronisation peut être partagé avec tous les 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 être appropriés pour la synchronisation entre les 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 Object Names.

Si un name 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 type différent existe déjà dans l’espace de noms, un WaitHandleCannotBeOpenedException objet 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é par initialCount et maximumCount. Si le sémaphore système nommé existe déjà et initialCountmaximumCount n’est pas utilisé, bien que les 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.

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 entre les limites de processus.

Si vous souhaitez savoir si un sémaphore système nommé existe, 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.

Voir aussi

• Threading managé
• Sémaphore

Source:

Semaphore.cs

Source:

Semaphore.cs

Source:

Semaphore.cs

Source:

Semaphore.cs

Source:

Semaphore.cs

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);

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

Exceptions

Exemples

L’exemple de code suivant illustre le comportement interprocesseur 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 c’est falsele cas, 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 bloque le troisième appel à WaitOne. Relâchez une ou plusieurs entrées dans la première copie du programme pour débloquer la seconde.

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

Il name peut être préfixé Global\ ou Local\ spécifier un espace de noms. Lorsque l’espace Global de noms est spécifié, l’objet de synchronisation peut être partagé avec tous les 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 être appropriés pour la synchronisation entre les 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 Object Names.

Si un name 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 type différent existe déjà dans l’espace de noms, un WaitHandleCannotBeOpenedException objet 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é par initialCount et maximumCount. Si le sémaphore système nommé existe déjà et initialCountmaximumCount n’est pas utilisé, bien que les valeurs non valides provoquent toujours des exceptions. Permet createdNew de déterminer si le sémaphore système a été créé.

Si initialCount elle maximumCountest inférieure à , 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 c’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 entre les limites de processus.

Voir aussi

• Threading managé
• Sémaphore

Source:

Semaphore.cs

Source:

Semaphore.cs

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

public Semaphore(int initialCount, int maximumCount, string? name, System.Threading.NamedWaitHandleOptions options);

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

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

Paramètres

Exceptions

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

Si un name objet de synchronisation 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é, sauf si options l’accès est limité à l’utilisateur actuel et que l’objet de synchronisation n’est pas compatible avec celui-ci, auquel cas un WaitHandleCannotBeOpenedException objet de synchronisation est levée. Si un objet de synchronisation d’un type différent existe déjà dans l’espace de noms, un WaitHandleCannotBeOpenedException objet est également 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é par initialCount et maximumCount. Si le sémaphore système nommé existe déjà et initialCountmaximumCount n’est pas utilisé, bien que les 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.

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 entre les limites de processus.

Si vous souhaitez savoir si un sémaphore système nommé existe, 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.

Sur Windows, options pouvez spécifier si le sémaphore nommé est accessible uniquement à l’utilisateur actuel ou à tous les utilisateurs. Il vous permet également de spécifier si le sémaphore nommé est accessible aux processus de la session active uniquement ou à toutes les sessions. Pour plus d’informations, consultez NamedWaitHandleOptions.

Voir aussi

• Threading managé
• Sémaphore

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

public Semaphore(int initialCount, int maximumCount, string name, out bool createdNew, System.Security.AccessControl.SemaphoreSecurity semaphoreSecurity);

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

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

Paramètres

Exceptions

Exemples

L’exemple de code suivant illustre le comportement interprocesseur d’un sémaphore nommé avec la sécurité du contrôle d’accès. L’exemple utilise la OpenExisting(String) surcharge de méthode pour tester l’existence d’un sémaphore nommé. Si le sémaphore n’existe pas, il est créé avec un nombre maximal de deux et avec la sécurité de contrôle d’accès qui refuse à l’utilisateur actuel le droit d’utiliser le sémaphore, mais accorde le droit de lire et de modifier les autorisations sur le sémaphore. Si vous exécutez l’exemple compilé à partir de deux fenêtres de commandes, la deuxième copie lève une exception de violation d’accès sur l’appel à la OpenExisting(String) méthode. L’exception est interceptée et l’exemple utilise la OpenExisting(String, SemaphoreRights) surcharge de méthode pour ouvrir le sémaphore avec les droits nécessaires pour lire et modifier les autorisations.

Une fois les autorisations modifiées, le sémaphore est ouvert avec les droits requis pour entrer et libérer. Si vous exécutez l’exemple compilé à partir d’une troisième fenêtre de commande, il s’exécute à l’aide des nouvelles autorisations.

using System;
using System.Threading;
using System.Security.AccessControl;

internal class Example
{
    internal static void Main()
    {
        const string semaphoreName = "SemaphoreExample5";

        Semaphore sem = null;
        bool doesNotExist = false;
        bool unauthorized = false;

        // Attempt to open the named semaphore.
        try
        {
            // Open the semaphore with (SemaphoreRights.Synchronize
            // | SemaphoreRights.Modify), to enter and release the
            // named semaphore.
            //
            sem = Semaphore.OpenExisting(semaphoreName);
        }
        catch(WaitHandleCannotBeOpenedException)
        {
            Console.WriteLine("Semaphore does not exist.");
            doesNotExist = true;
        }
        catch(UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
            unauthorized = true;
        }

        // There are three cases: (1) The semaphore does not exist.
        // (2) The semaphore exists, but the current user doesn't 
        // have access. (3) The semaphore exists and the user has
        // access.
        //
        if (doesNotExist)
        {
            // The semaphore does not exist, so create it.
            //
            // 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 an access control list (ACL) that denies the
            // current user the right to enter or release the 
            // semaphore, but allows the right to read and change
            // security information for the semaphore.
            //
            string user = Environment.UserDomainName + "\\" 
                + Environment.UserName;
            SemaphoreSecurity semSec = new SemaphoreSecurity();

            SemaphoreAccessRule rule = new SemaphoreAccessRule(
                user, 
                SemaphoreRights.Synchronize | SemaphoreRights.Modify, 
                AccessControlType.Deny);
            semSec.AddAccessRule(rule);

            rule = new SemaphoreAccessRule(
                user, 
                SemaphoreRights.ReadPermissions | SemaphoreRights.ChangePermissions,
                AccessControlType.Allow);
            semSec.AddAccessRule(rule);

            // Create a Semaphore object that represents the system
            // semaphore named by the constant 'semaphoreName', with
            // maximum count three, initial count three, and the
            // specified security access. The Boolean value that 
            // indicates creation of the underlying system object is
            // placed in semaphoreWasCreated.
            //
            sem = new Semaphore(3, 3, semaphoreName, 
                out semaphoreWasCreated, semSec);

            // If the named system semaphore was created, it can be
            // used by the current instance of this program, even 
            // though the current user is denied access. The current
            // program enters the semaphore. Otherwise, exit the
            // program.
            // 
            if (semaphoreWasCreated)
            {
                Console.WriteLine("Created the semaphore.");
            }
            else
            {
                Console.WriteLine("Unable to create the semaphore.");
                return;
            }
        }
        else if (unauthorized)
        {
            // Open the semaphore to read and change the access
            // control security. The access control security defined
            // above allows the current user to do this.
            //
            try
            {
                sem = Semaphore.OpenExisting(
                    semaphoreName, 
                    SemaphoreRights.ReadPermissions 
                        | SemaphoreRights.ChangePermissions);

                // Get the current ACL. This requires 
                // SemaphoreRights.ReadPermissions.
                SemaphoreSecurity semSec = sem.GetAccessControl();
                
                string user = Environment.UserDomainName + "\\" 
                    + Environment.UserName;

                // First, the rule that denied the current user 
                // the right to enter and release the semaphore must
                // be removed.
                SemaphoreAccessRule rule = new SemaphoreAccessRule(
                    user, 
                    SemaphoreRights.Synchronize | SemaphoreRights.Modify, 
                    AccessControlType.Deny);
                semSec.RemoveAccessRule(rule);

                // Now grant the user the correct rights.
                // 
                rule = new SemaphoreAccessRule(user, 
                     SemaphoreRights.Synchronize | SemaphoreRights.Modify, 
                     AccessControlType.Allow);
                semSec.AddAccessRule(rule);

                // Update the ACL. This requires
                // SemaphoreRights.ChangePermissions.
                sem.SetAccessControl(semSec);

                Console.WriteLine("Updated semaphore security.");

                // Open the semaphore with (SemaphoreRights.Synchronize 
                // | SemaphoreRights.Modify), the rights required to
                // enter and release the semaphore.
                //
                sem = Semaphore.OpenExisting(semaphoreName);
            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unable to change permissions: {0}", ex.Message);
                return;
            }
        }

        // Enter the semaphore, and hold it until the program
        // exits.
        //
        try
        {
            sem.WaitOne();
            Console.WriteLine("Entered the semaphore.");
            Console.WriteLine("Press the Enter key to exit.");
            Console.ReadLine();
            sem.Release();
        }
        catch(UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
        }
    }
}

Imports System.Threading
Imports System.Security.AccessControl

Friend Class Example

    <MTAThread> _
    Friend Shared Sub Main()
        Const semaphoreName As String = "SemaphoreExample5"

        Dim sem As Semaphore = Nothing
        Dim doesNotExist as Boolean = False
        Dim unauthorized As Boolean = False

        ' Attempt to open the named semaphore.
        Try
            ' Open the semaphore with (SemaphoreRights.Synchronize
            ' Or SemaphoreRights.Modify), to enter and release the
            ' named semaphore.
            '
            sem = Semaphore.OpenExisting(semaphoreName)
        Catch ex As WaitHandleCannotBeOpenedException
            Console.WriteLine("Semaphore does not exist.")
            doesNotExist = True
        Catch ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", ex.Message)
            unauthorized = True
        End Try

        ' There are three cases: (1) The semaphore does not exist.
        ' (2) The semaphore exists, but the current user doesn't 
        ' have access. (3) The semaphore exists and the user has
        ' access.
        '
        If doesNotExist Then
            ' The semaphore does not exist, so create it.
            '
            ' 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 an access control list (ACL) that denies the
            ' current user the right to enter or release the 
            ' semaphore, but allows the right to read and change
            ' security information for the semaphore.
            '
            Dim user As String = Environment.UserDomainName _ 
                & "\" & Environment.UserName
            Dim semSec As New SemaphoreSecurity()

            Dim rule As New SemaphoreAccessRule(user, _
                SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                AccessControlType.Deny)
            semSec.AddAccessRule(rule)

            rule = New SemaphoreAccessRule(user, _
                SemaphoreRights.ReadPermissions Or _
                SemaphoreRights.ChangePermissions, _
                AccessControlType.Allow)
            semSec.AddAccessRule(rule)

            ' Create a Semaphore object that represents the system
            ' semaphore named by the constant 'semaphoreName', with
            ' maximum count three, initial count three, and the
            ' specified security access. The Boolean value that 
            ' indicates creation of the underlying system object is
            ' placed in semaphoreWasCreated.
            '
            sem = New Semaphore(3, 3, semaphoreName, _
                semaphoreWasCreated, semSec)

            ' If the named system semaphore was created, it can be
            ' used by the current instance of this program, even 
            ' though the current user is denied access. The current
            ' program enters the semaphore. Otherwise, exit the
            ' program.
            ' 
            If semaphoreWasCreated Then
                Console.WriteLine("Created the semaphore.")
            Else
                Console.WriteLine("Unable to create the semaphore.")
                Return
            End If

        ElseIf unauthorized Then

            ' Open the semaphore to read and change the access
            ' control security. The access control security defined
            ' above allows the current user to do this.
            '
            Try
                sem = Semaphore.OpenExisting(semaphoreName, _
                    SemaphoreRights.ReadPermissions Or _
                    SemaphoreRights.ChangePermissions)

                ' Get the current ACL. This requires 
                ' SemaphoreRights.ReadPermissions.
                Dim semSec As SemaphoreSecurity = sem.GetAccessControl()
                
                Dim user As String = Environment.UserDomainName _ 
                    & "\" & Environment.UserName

                ' First, the rule that denied the current user 
                ' the right to enter and release the semaphore must
                ' be removed.
                Dim rule As New SemaphoreAccessRule(user, _
                    SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                    AccessControlType.Deny)
                semSec.RemoveAccessRule(rule)

                ' Now grant the user the correct rights.
                ' 
                rule = New SemaphoreAccessRule(user, _
                    SemaphoreRights.Synchronize Or SemaphoreRights.Modify, _
                    AccessControlType.Allow)
                semSec.AddAccessRule(rule)

                ' Update the ACL. This requires
                ' SemaphoreRights.ChangePermissions.
                sem.SetAccessControl(semSec)

                Console.WriteLine("Updated semaphore security.")

                ' Open the semaphore with (SemaphoreRights.Synchronize 
                ' Or SemaphoreRights.Modify), the rights required to
                ' enter and release the semaphore.
                '
                sem = Semaphore.OpenExisting(semaphoreName)

            Catch ex As UnauthorizedAccessException
                Console.WriteLine("Unable to change permissions: {0}", _
                    ex.Message)
                Return
            End Try

        End If

        ' Enter the semaphore, and hold it until the program
        ' exits.
        '
        Try
            sem.WaitOne()
            Console.WriteLine("Entered the semaphore.")
            Console.WriteLine("Press the Enter key to exit.")
            Console.ReadLine()
            sem.Release()
        Catch ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", _
                ex.Message)
        End Try
    End Sub 
End Class

Remarques

Utilisez ce constructeur pour appliquer la sécurité du contrôle d’accès à un sémaphore système nommé lorsqu’il est créé, ce qui empêche tout autre code de prendre le contrôle du sémaphore.

Il name peut être préfixé Global\ ou Local\ spécifier un espace de noms. Lorsque l’espace Global de noms est spécifié, l’objet de synchronisation peut être partagé avec tous les 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 être appropriés pour la synchronisation entre les 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 Object Names.

Si un name 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 type différent existe déjà dans l’espace de noms, un WaitHandleCannotBeOpenedException objet 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 la sécurité de contrôle d’accès spécifiée. Si le sémaphore nommé existe, la sécurité du contrôle d’accès spécifiée est ignorée.

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

Si initialCount elle maximumCountest inférieure à , 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 c’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 entre les limites de processus.

Voir aussi

• Threading managé
• Sémaphore

Source:

Semaphore.cs

Source:

Semaphore.cs

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

public Semaphore(int initialCount, int maximumCount, string? name, System.Threading.NamedWaitHandleOptions options, out bool createdNew);

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

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

Paramètres

Exceptions

Remarques

Si un name objet de synchronisation 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é, sauf si options l’accès est limité à l’utilisateur actuel et que l’objet de synchronisation n’est pas compatible avec celui-ci, auquel cas un WaitHandleCannotBeOpenedException objet de synchronisation est levée. Si un objet de synchronisation d’un type différent existe déjà dans l’espace de noms, un WaitHandleCannotBeOpenedException objet est également 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é par initialCount et maximumCount. Si le sémaphore système nommé existe déjà et initialCountmaximumCount n’est pas utilisé, bien que les valeurs non valides provoquent toujours des exceptions. Utilisez le createdNew paramètre pour déterminer si le sémaphore système a été créé par ce constructeur.

Si initialCount elle maximumCountest inférieure à , 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 c’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 entre les limites de processus.

Sur Windows, options pouvez spécifier si le sémaphore nommé est accessible uniquement à l’utilisateur actuel ou à tous les utilisateurs. Il vous permet également de spécifier si le sémaphore nommé est accessible aux processus de la session active uniquement ou à toutes les sessions. Pour plus d’informations, consultez NamedWaitHandleOptions.

Voir aussi

• Threading managé
• Sémaphore