Semaphore.Release Método

Definição

O semáforo é encerrado.Exits the semaphore.

Sobrecargas

Release()

Sai do sinal e retorna à contagem anterior.Exits the semaphore and returns the previous count.

Release(Int32)

Sai do sinal de um número de vezes especificado e retorna à contagem anterior.Exits the semaphore a specified number of times and returns the previous count.

Release()

Sai do sinal e retorna à contagem anterior.Exits the semaphore and returns the previous count.

public:
 int Release();
public int Release ();
member this.Release : unit -> int
Public Function Release () As Integer

Retornos

Int32

A contagem no sinal antes do método Release ser chamado.The count on the semaphore before the Release method was called.

Exceções

A contagem de semáforo já está no valor máximo.The semaphore count is already at the maximum value.

Ocorreu um erro de Win32 com um semáforo nomeado.A Win32 error occurred with a named semaphore.

O semáforo atual representa um semáforo de sistema nomeado, mas o usuário não tem Modify.The current semaphore represents a named system semaphore, but the user does not have Modify.

- ou --or- O sinal do atual representa um sinal de sistema nomeado, mas não foi aberto com Modify.The current semaphore represents a named system semaphore, but it was not opened with Modify.

Exemplos

O exemplo de código a seguir cria um semáforo com uma contagem máxima de três e uma contagem inicial de zero.The following code example creates a semaphore with a maximum count of three and an initial count of zero. O exemplo inicia cinco threads, que bloqueia a espera pelo semáforo.The example starts five threads, which block waiting for the semaphore. O thread principal usa a Release(Int32) sobrecarga do método para aumentar a contagem de semáforos para seu máximo, permitindo que três threads insiram o semáforo.The main thread uses the Release(Int32) method overload to increase the semaphore count to its maximum, allowing three threads to enter the semaphore. Cada thread usa o Thread.Sleep método para aguardar um segundo, para simular o trabalho e, em seguida, chama a Release() sobrecarga do método para liberar o semáforo.Each thread uses the Thread.Sleep method to wait for one second, to simulate work, and then calls the Release() method overload to release the semaphore.

Cada vez que o semáforo é liberado, a contagem de semáforo anterior é exibida.Each time the semaphore is released, the previous semaphore count is displayed. Mensagens do console acompanham o uso de semáforo.Console messages track semaphore use. O intervalo de trabalho simulado aumenta um pouco para cada thread, para facilitar a leitura da saída.The simulated work interval is increased slightly for each thread, to make the output easier to read.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Public Class Example

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

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

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

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

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

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

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

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

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

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

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

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

Comentários

Os threads normalmente usam o WaitOne método para inserir o semáforo e normalmente usam essa sobrecarga de método para sair.Threads typically use the WaitOne method to enter the semaphore, and they typically use this method overload to exit.

Se um SemaphoreFullException for gerado pelo Release método, ele não indica necessariamente um problema com o thread de chamada.If a SemaphoreFullException is thrown by the Release method, it does not necessarily indicate a problem with the calling thread. Um erro de programação em outro thread pode ter causado que o thread saiu do semáforo mais vezes do que foi inserido.A programming error in another thread might have caused that thread to exit the semaphore more times than it entered.

Se o Semaphore objeto atual representa um semáforo de sistema nomeado, o usuário deve ter SemaphoreRights.Modify direitos e o semáforo deve ter sido aberto com SemaphoreRights.Modify direitos.If the current Semaphore object represents a named system semaphore, the user must have SemaphoreRights.Modify rights and the semaphore must have been opened with SemaphoreRights.Modify rights.

Confira também

Aplica-se a

Release(Int32)

Sai do sinal de um número de vezes especificado e retorna à contagem anterior.Exits the semaphore a specified number of times and returns the previous count.

public:
 int Release(int releaseCount);
public int Release (int releaseCount);
member this.Release : int -> int
Public Function Release (releaseCount As Integer) As Integer

Parâmetros

releaseCount
Int32

O número de vezes para sair do sinal.The number of times to exit the semaphore.

Retornos

Int32

A contagem no sinal antes do método Release ser chamado.The count on the semaphore before the Release method was called.

Exceções

releaseCount é menor que 1.releaseCount is less than 1.

A contagem de semáforo já está no valor máximo.The semaphore count is already at the maximum value.

Ocorreu um erro de Win32 com um semáforo nomeado.A Win32 error occurred with a named semaphore.

O semáforo atual representa um semáforo de sistema nomeado, mas o usuário não tem direitos de Modify.The current semaphore represents a named system semaphore, but the user does not have Modify rights.

- ou --or- O sinal atual representa um sinal de sistema nomeado, mas não foi aberto com direitos de Modify.The current semaphore represents a named system semaphore, but it was not opened with Modify rights.

Exemplos

O exemplo de código a seguir cria um semáforo com uma contagem máxima de três e uma contagem inicial de zero.The following code example creates a semaphore with a maximum count of three and an initial count of zero. O exemplo inicia cinco threads, que bloqueia a espera pelo semáforo.The example starts five threads, which block waiting for the semaphore. O thread principal usa a Release(Int32) sobrecarga do método para aumentar a contagem de semáforos para seu máximo, permitindo que três threads insiram o semáforo.The main thread uses the Release(Int32) method overload to increase the semaphore count to its maximum, allowing three threads to enter the semaphore. Cada thread usa o Thread.Sleep método para aguardar um segundo, para simular o trabalho e, em seguida, chama a Release() sobrecarga do método para liberar o semáforo.Each thread uses the Thread.Sleep method to wait for one second, to simulate work, and then calls the Release() method overload to release the semaphore.

Cada vez que o semáforo é liberado, a contagem de semáforo anterior é exibida.Each time the semaphore is released, the previous semaphore count is displayed. Mensagens do console acompanham o uso de semáforo.Console messages track semaphore use. O intervalo de trabalho simulado aumenta um pouco para cada thread, para facilitar a leitura da saída.The simulated work interval is increased slightly for each thread, to make the output easier to read.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Public Class Example

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

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

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

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

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

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

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

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

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

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

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

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

Comentários

Se um thread tiver inserido o semáforo várias vezes, essa sobrecarga de método permitirá que toda a contagem de semáforo seja restaurada com uma chamada.If a thread has entered the semaphore multiple times, this method overload allows the entire semaphore count to be restored with one call.

Se um SemaphoreFullException for gerado pelo Release método, ele não indica necessariamente um problema com o thread de chamada.If a SemaphoreFullException is thrown by the Release method, it does not necessarily indicate a problem with the calling thread. Um erro de programação em outro thread pode ter causado que o thread saiu do semáforo mais vezes do que foi inserido.A programming error in another thread might have caused that thread to exit the semaphore more times than it entered.

Se o Semaphore objeto atual representa um semáforo de sistema nomeado, o usuário deve ter SemaphoreRights.Modify direitos e o semáforo deve ter sido aberto com SemaphoreRights.Modify direitos.If the current Semaphore object represents a named system semaphore, the user must have SemaphoreRights.Modify rights and the semaphore must have been opened with SemaphoreRights.Modify rights.

Confira também

Aplica-se a