Semaphore.Release Semaphore.Release Semaphore.Release Semaphore.Release Method

Definizione

Esce dal semaforo.Exits the semaphore.

Overload

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

Esce dal semaforo e restituisce il conteggio precedente.Exits the semaphore and returns the previous count.

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

Esce dal semaforo il numero di volte specificato e restituisce il conteggio precedente.Exits the semaphore a specified number of times and returns the previous count.

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

Esce dal semaforo e restituisce il conteggio precedente.Exits the semaphore and returns the previous count.

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

Restituisce

Conteggio del semaforo prima della chiamata del metodo Release.The count on the semaphore before the Release method was called.

Eccezioni

Il conteggio del semaforo ha già raggiunto il valore massimo.The semaphore count is already at the maximum value.

Si è verificato un errore Win32 relativo a un semaforo denominato.A Win32 error occurred with a named semaphore.

Il semaforo corrente rappresenta un semaforo di sistema denominato, ma l'utente non dispone di Modify.The current semaphore represents a named system semaphore, but the user does not have Modify.

In alternativa-or- Il semaforo corrente rappresenta un semaforo di sistema denominato, ma non è stato aperto con Modify.The current semaphore represents a named system semaphore, but it was not opened with Modify.

Esempi

Esempio di codice seguente crea un semaforo con un numero massimo di tre e un conteggio iniziale pari a zero.The following code example creates a semaphore with a maximum count of three and an initial count of zero. L'esempio avviati cinque thread, che bloccherà in attesa per il semaforo.The example starts five threads, which block waiting for the semaphore. Utilizzate dal thread principale di Release(Int32) overload del metodo per aumentare il conteggio del semaforo sul valore massimo, consentendo a tre thread di accedere al semaforo.The main thread uses the Release(Int32) method overload to increase the semaphore count to its maximum, allowing three threads to enter the semaphore. Ogni thread Usa la Thread.Sleep metodo per attendere un secondo, per simulare il funzionamento e quindi chiama il Release() overload del metodo per rilasciare il semaforo.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.

Ogni volta che viene rilasciato il semaforo, viene visualizzato il conteggio del semaforo precedente.Each time the semaphore is released, the previous semaphore count is displayed. Utilizzo di semaforo track messaggi della console.Console messages track semaphore use. L'intervallo di lavoro simulato viene aumentato leggermente per ogni thread, per semplificare la lettura dell'output.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
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

Commenti

Thread usano in genere il WaitOne metodo per immettere il semaforo che in genere utilizzare questo overload del metodo per uscire.Threads typically use the WaitOne method to enter the semaphore, and they typically use this method overload to exit.

Se un SemaphoreFullException generata dal Release metodo, non indica necessariamente un problema con il thread chiamante.If a SemaphoreFullException is thrown by the Release method, it does not necessarily indicate a problem with the calling thread. Un errore di programmazione in un altro thread potrebbe aver causato tale thread uscite dal semaforo più volte rispetto agli accessi.A programming error in another thread might have caused that thread to exit the semaphore more times than it entered.

Se l'oggetto corrente Semaphore oggetto rappresenta un semaforo di sistema denominato, l'utente deve disporre SemaphoreRights.Modify diritti e il semaforo necessario sia stato aperto con SemaphoreRights.Modify diritti.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.

Vedi anche

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

Esce dal semaforo il numero di volte specificato e restituisce il conteggio precedente.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

Parametri

releaseCount
Int32 Int32 Int32 Int32

Numero di uscite dal semaforo.The number of times to exit the semaphore.

Restituisce

Conteggio del semaforo prima della chiamata del metodo Release.The count on the semaphore before the Release method was called.

Eccezioni

Il conteggio del semaforo ha già raggiunto il valore massimo.The semaphore count is already at the maximum value.

Si è verificato un errore Win32 relativo a un semaforo denominato.A Win32 error occurred with a named semaphore.

Il semaforo corrente rappresenta un semaforo di sistema denominato, ma l'utente non dispone di diritti Modify.The current semaphore represents a named system semaphore, but the user does not have Modify rights.

In alternativa-or- Il semaforo corrente rappresenta un semaforo di sistema denominato, ma non è stato aperto con i diritti Modify.The current semaphore represents a named system semaphore, but it was not opened with Modify rights.

Esempi

Esempio di codice seguente crea un semaforo con un numero massimo di tre e un conteggio iniziale pari a zero.The following code example creates a semaphore with a maximum count of three and an initial count of zero. L'esempio avviati cinque thread, che bloccherà in attesa per il semaforo.The example starts five threads, which block waiting for the semaphore. Utilizzate dal thread principale di Release(Int32) overload del metodo per aumentare il conteggio del semaforo sul valore massimo, consentendo a tre thread di accedere al semaforo.The main thread uses the Release(Int32) method overload to increase the semaphore count to its maximum, allowing three threads to enter the semaphore. Ogni thread Usa la Thread.Sleep metodo per attendere un secondo, per simulare il funzionamento e quindi chiama il Release() overload del metodo per rilasciare il semaforo.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.

Ogni volta che viene rilasciato il semaforo, viene visualizzato il conteggio del semaforo precedente.Each time the semaphore is released, the previous semaphore count is displayed. Utilizzo di semaforo track messaggi della console.Console messages track semaphore use. L'intervallo di lavoro simulato viene aumentato leggermente per ogni thread, per semplificare la lettura dell'output.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
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

Commenti

Se un thread ha acceduto al semaforo più volte, questo overload del metodo consente il conteggio del semaforo intero deve essere ripristinato con una sola chiamata.If a thread has entered the semaphore multiple times, this method overload allows the entire semaphore count to be restored with one call.

Se un SemaphoreFullException generata dal Release metodo, non indica necessariamente un problema con il thread chiamante.If a SemaphoreFullException is thrown by the Release method, it does not necessarily indicate a problem with the calling thread. Un errore di programmazione in un altro thread potrebbe aver causato tale thread uscite dal semaforo più volte rispetto agli accessi.A programming error in another thread might have caused that thread to exit the semaphore more times than it entered.

Se l'oggetto corrente Semaphore oggetto rappresenta un semaforo di sistema denominato, l'utente deve disporre SemaphoreRights.Modify diritti e il semaforo necessario sia stato aperto con SemaphoreRights.Modify diritti.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.

Vedi anche

Si applica a