Semaphore Construtores

Origem:

Semaphore.cs

Origem:

Semaphore.cs

Origem:

Semaphore.cs

Origem:

Semaphore.cs

Origem:

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)

Parâmetros

Exceções

Exemplos

O exemplo seguinte cria um semáforo com contagem máxima de três e contagem inicial de zero. O exemplo inicia cinco threads, que bloqueiam a espera do semáforo. A thread principal utiliza o Release(Int32) método overload para aumentar a contagem de semáforos ao máximo, permitindo que três threads entrem no semáforo. Cada thread usa o Thread.Sleep método para esperar um segundo para simular o trabalho, e depois chama o Release() método de sobrecarga para libertar o semáforo. Cada vez que o semáforo é libertado, é apresentada a contagem anterior de semáforos. As mensagens de consola acompanham o uso de semáforos. O intervalo de trabalho simulado é ligeiramente aumentado para cada thread, para facilitar a leitura da saída.

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

Observações

Este construtor inicializa um semáforo sem nome. Todas as threads que utilizam uma instância de tal semáforo devem ter referências à instância.

Se initialCount for menor que maximumCount, o efeito é o mesmo que se a thread atual tivesse chamado WaitOne (maximumCount menos initialCount) vezes. Se não quiser reservar entradas para a thread que cria o semáforo, use o mesmo número para maximumCount e initialCount.

Ver também

• de threading gerenciado
• Semáforo

Origem:

Semaphore.cs

Origem:

Semaphore.cs

Origem:

Semaphore.cs

Origem:

Semaphore.cs

Origem:

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)

Parâmetros

Exceções

Exemplos

O exemplo de código seguinte demonstra o comportamento cruzado de processos de um semáforo nomeado. O exemplo cria um semáforo nomeado com uma contagem máxima de cinco e uma contagem inicial de cinco. O programa faz três chamadas ao WaitOne método. Assim, se executares o exemplo compilado a partir de duas janelas de comandos, a segunda cópia irá bloquear na terceira chamada para WaitOne. Liberte uma ou mais entradas na primeira cópia do programa para desbloquear a segunda.

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

Observações

Este construtor inicializa um Semaphore objeto que representa um semáforo de sistema nomeado. Podes criar múltiplos Semaphore objetos que representam o mesmo semáforo de sistema com nome.

Podem name ser precedidos por Global\ ou Local\ para especificar um namespace. Quando o Global namespace é especificado, o objeto de sincronização pode ser partilhado com quaisquer processos no sistema. Quando o Local namespace é especificado, que é também o padrão quando não há namespace especificado, o objeto de sincronização pode ser partilhado com processos na mesma sessão. No Windows, uma sessão é uma sessão de login, e os serviços normalmente correm numa sessão diferente e não interativa. Em sistemas operativos do tipo Unix, cada shell tem a sua própria sessão. Os objetos de sincronização local da sessão podem ser apropriados para sincronizar entre processos com uma relação pai/filho, onde todos correm na mesma sessão. Para mais informações sobre nomes de objetos de sincronização no Windows, veja Object Names.

Se a name for fornecido e um objeto de sincronização do tipo solicitado já existir no namespace, o objeto de sincronização existente é utilizado. Se já existir um objeto de sincronização de outro tipo no namespace, um WaitHandleCannotBeOpenedException lançamento é lançado. Caso contrário, é criado um novo objeto de sincronização.

Se o semáforo do sistema nomeado não existir, é criado com a contagem inicial e a contagem máxima especificadas por initialCount e maximumCount. Se o semáforo do sistema nomeado já existir e initialCountmaximumCount não for utilizado, embora valores inválidos ainda causem exceções. Se precisares de determinar se um semáforo de sistema nomeado foi criado ou não, usa a Semaphore(Int32, Int32, String, Boolean) sobrecarga de construtores em vez disso.

Se especificar null ou uma cadeia vazia para name, é criado um semáforo local, como se tivesse chamado a Semaphore(Int32, Int32) sobrecarga do construtor.

Como os semáforos nomeados são visíveis em todo o sistema operativo, podem ser usados para coordenar o uso de recursos através dos limites dos processos.

Se quiser descobrir se existe um semáforo de sistema nomeado, use o OpenExisting método. O OpenExisting método tenta abrir um semáforo nomeado existente e lança uma exceção se o semáforo do sistema não existir.

Ver também

• de threading gerenciado
• Semáforo

Origem:

Semaphore.cs

Origem:

Semaphore.cs

Origem:

Semaphore.cs

Origem:

Semaphore.cs

Origem:

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)

Parâmetros

Exceções

Exemplos

O exemplo de código seguinte demonstra o comportamento cruzado de processos de um semáforo nomeado. O exemplo cria um semáforo nomeado com uma contagem máxima de cinco e uma contagem inicial de dois. Ou seja, reserva três entradas para o thread que chama o construtor. Se createNew for false, o programa faz três chamadas ao WaitOne método. Assim, se executares o exemplo compilado a partir de duas janelas de comandos, a segunda cópia irá bloquear na terceira chamada para WaitOne. Liberte uma ou mais entradas na primeira cópia do programa para desbloquear a segunda.

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

Observações

Podem name ser precedidos por Global\ ou Local\ para especificar um namespace. Quando o Global namespace é especificado, o objeto de sincronização pode ser partilhado com quaisquer processos no sistema. Quando o Local namespace é especificado, que é também o padrão quando não há namespace especificado, o objeto de sincronização pode ser partilhado com processos na mesma sessão. No Windows, uma sessão é uma sessão de login, e os serviços normalmente correm numa sessão diferente e não interativa. Em sistemas operativos do tipo Unix, cada shell tem a sua própria sessão. Os objetos de sincronização local da sessão podem ser apropriados para sincronizar entre processos com uma relação pai/filho, onde todos correm na mesma sessão. Para mais informações sobre nomes de objetos de sincronização no Windows, veja Object Names.

Se a name for fornecido e um objeto de sincronização do tipo solicitado já existir no namespace, o objeto de sincronização existente é utilizado. Se já existir um objeto de sincronização de outro tipo no namespace, um WaitHandleCannotBeOpenedException lançamento é lançado. Caso contrário, é criado um novo objeto de sincronização.

Este construtor inicializa um Semaphore objeto que representa um semáforo de sistema nomeado. Podes criar múltiplos Semaphore objetos que representam o mesmo semáforo de sistema com nome.

Se o semáforo do sistema nomeado não existir, é criado com a contagem inicial e a contagem máxima especificadas por initialCount e maximumCount. Se o semáforo do sistema nomeado já existir e initialCountmaximumCount não for utilizado, embora valores inválidos ainda causem exceções. Usar createdNew para determinar se o semáforo do sistema foi criado.

Se initialCount for menor que maximumCount, e createdNew for true, o efeito é o mesmo que se o thread atual tivesse chamado WaitOne (maximumCount menos initialCount) vezes.

Se especificar null ou uma cadeia vazia para name, é criado um semáforo local, como se tivesse chamado a Semaphore(Int32, Int32) sobrecarga do construtor. Neste caso, createdNew é sempre true.

Como os semáforos nomeados são visíveis em todo o sistema operativo, podem ser usados para coordenar o uso de recursos através dos limites dos processos.

Ver também

• de threading gerenciado
• Semáforo

Origem:

Semaphore.cs

Origem:

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)

Parâmetros

Exceções

Observações

Este construtor inicializa um Semaphore objeto que representa um semáforo de sistema nomeado. Podes criar múltiplos Semaphore objetos que representam o mesmo semáforo de sistema com nome.

Se a name for fornecido e um objeto de sincronização do tipo solicitado já existir no namespace, o objeto de sincronização existente é usado a menos que options especifique acesso limitado ao utilizador atual e o objeto de sincronização não seja compatível com ele, caso em que a WaitHandleCannotBeOpenedException é lançado. Se já existir um objeto de sincronização de um tipo diferente no namespace, um WaitHandleCannotBeOpenedException também é lançado. Caso contrário, é criado um novo objeto de sincronização.

Se o semáforo do sistema nomeado não existir, é criado com a contagem inicial e a contagem máxima especificadas por initialCount e maximumCount. Se o semáforo do sistema nomeado já existir e initialCountmaximumCount não for utilizado, embora valores inválidos ainda causem exceções. Se precisares de determinar se um semáforo de sistema nomeado foi criado ou não, usa a Semaphore(Int32, Int32, String, Boolean) sobrecarga de construtores em vez disso.

Se especificar null ou uma cadeia vazia para name, é criado um semáforo local, como se tivesse chamado a Semaphore(Int32, Int32) sobrecarga do construtor.

Como os semáforos nomeados são visíveis em todo o sistema operativo, podem ser usados para coordenar o uso de recursos através dos limites dos processos.

Se quiser descobrir se existe um semáforo de sistema nomeado, use o OpenExisting método. O OpenExisting método tenta abrir um semáforo nomeado existente e lança uma exceção se o semáforo do sistema não existir.

No Windows, pode ser fornecido options para especificar se o semáforo nomeado é acessível apenas ao utilizador atual ou a todos os utilizadores. Também permite especificar se o semáforo nomeado é acessível apenas a processos na sessão atual ou a todas as sessões. Para obter mais informações, veja NamedWaitHandleOptions.

Ver também

• de threading gerenciado
• Semáforo

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)

Parâmetros

Exceções

Exemplos

O exemplo de código seguinte demonstra o comportamento cruzado de processos de um semáforo nomeado com segurança de controlo de acessos. O exemplo utiliza o OpenExisting(String) método overload para testar a existência de um semáforo nomeado. Se o semáforo não existir, é criado com uma contagem máxima de dois e com controlo de acesso que nega ao utilizador atual o direito de usar o semáforo, mas concede o direito de ler e alterar permissões sobre o semáforo. Se executares o exemplo compilado a partir de duas janelas de comandos, a segunda cópia lançará uma exceção de violação de acesso na chamada ao OpenExisting(String) método. A exceção é apanhada, e o exemplo usa a OpenExisting(String, SemaphoreRights) sobrecarga do método para abrir o semáforo com os direitos necessários para ler e alterar as permissões.

Após a alteração das permissões, o semáforo é aberto com os direitos necessários para entrar e libertar. Se executares o exemplo compilado a partir de uma terceira janela de comandos, ele é executado usando as novas permissões.

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

Observações

Use este construtor para aplicar segurança de controlo de acesso a um semáforo de sistema nomeado quando este é criado, impedindo que outro código assuma o controlo do semáforo.

Podem name ser precedidos por Global\ ou Local\ para especificar um namespace. Quando o Global namespace é especificado, o objeto de sincronização pode ser partilhado com quaisquer processos no sistema. Quando o Local namespace é especificado, que é também o padrão quando não há namespace especificado, o objeto de sincronização pode ser partilhado com processos na mesma sessão. No Windows, uma sessão é uma sessão de login, e os serviços normalmente correm numa sessão diferente e não interativa. Em sistemas operativos do tipo Unix, cada shell tem a sua própria sessão. Os objetos de sincronização local da sessão podem ser apropriados para sincronizar entre processos com uma relação pai/filho, onde todos correm na mesma sessão. Para mais informações sobre nomes de objetos de sincronização no Windows, veja Object Names.

Se a name for fornecido e um objeto de sincronização do tipo solicitado já existir no namespace, o objeto de sincronização existente é utilizado. Se já existir um objeto de sincronização de outro tipo no namespace, um WaitHandleCannotBeOpenedException lançamento é lançado. Caso contrário, é criado um novo objeto de sincronização.

Este construtor inicializa um Semaphore objeto que representa um semáforo de sistema nomeado. Podes criar múltiplos Semaphore objetos que representam o mesmo semáforo de sistema com nome.

Se o semáforo do sistema nomeado não existir, é criado com a segurança de controlo de acesso especificada. Se o semáforo nomeado existir, a segurança de controlo de acesso especificada é ignorada.

Se o semáforo do sistema nomeado não existir, é criado com a contagem inicial e a contagem máxima especificadas por initialCount e maximumCount. Se o semáforo do sistema nomeado já existir e initialCountmaximumCount não for utilizado, embora valores inválidos ainda causem exceções. Use o createdNew parâmetro para determinar se o semáforo do sistema foi criado por este construtor.

Se initialCount for menor que maximumCount, e createdNew for true, o efeito é o mesmo que se o thread atual tivesse chamado WaitOne (maximumCount menos initialCount) vezes.

Se especificar null ou uma cadeia vazia para name, é criado um semáforo local, como se tivesse chamado a Semaphore(Int32, Int32) sobrecarga do construtor. Neste caso, createdNew é sempre true.

Como os semáforos nomeados são visíveis em todo o sistema operativo, podem ser usados para coordenar o uso de recursos através dos limites dos processos.

Ver também

• de threading gerenciado
• Semáforo

Origem:

Semaphore.cs

Origem:

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)

Parâmetros

Exceções

Observações

Se a name for fornecido e um objeto de sincronização do tipo solicitado já existir no namespace, o objeto de sincronização existente é usado a menos que options especifique acesso limitado ao utilizador atual e o objeto de sincronização não seja compatível com ele, caso em que a WaitHandleCannotBeOpenedException é lançado. Se já existir um objeto de sincronização de um tipo diferente no namespace, um WaitHandleCannotBeOpenedException também é lançado. Caso contrário, é criado um novo objeto de sincronização.

Este construtor inicializa um Semaphore objeto que representa um semáforo de sistema nomeado. Podes criar múltiplos Semaphore objetos que representam o mesmo semáforo de sistema com nome.

Se o semáforo do sistema nomeado não existir, é criado com a contagem inicial e a contagem máxima especificadas por initialCount e maximumCount. Se o semáforo do sistema nomeado já existir e initialCountmaximumCount não for utilizado, embora valores inválidos ainda causem exceções. Use o createdNew parâmetro para determinar se o semáforo do sistema foi criado por este construtor.

Se initialCount for menor que maximumCount, e createdNew for true, o efeito é o mesmo que se o thread atual tivesse chamado WaitOne (maximumCount menos initialCount) vezes.

Se especificar null ou uma cadeia vazia para name, é criado um semáforo local, como se tivesse chamado a Semaphore(Int32, Int32) sobrecarga do construtor. Neste caso, createdNew é sempre true.

Como os semáforos nomeados são visíveis em todo o sistema operativo, podem ser usados para coordenar o uso de recursos através dos limites dos processos.

No Windows, pode ser fornecido options para especificar se o semáforo nomeado é acessível apenas ao utilizador atual ou a todos os utilizadores. Também permite especificar se o semáforo nomeado é acessível apenas a processos na sessão atual ou a todas as sessões. Para obter mais informações, veja NamedWaitHandleOptions.

Ver também

• de threading gerenciado
• Semáforo