Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Semaphore.Release (Int32)

 

Data di pubblicazione: ottobre 2016

Esce dal semaforo il numero di volte specificato e restituisce il conteggio precedente.

Spazio dei nomi:   System.Threading
Assembly:  System (in System.dll)

public int Release(
	int releaseCount
)

Parametri

releaseCount
Type: System.Int32

Numero di uscite dal semaforo.

Valore restituito

Type: System.Int32

Conteggio del semaforo prima della chiamata del metodo Release.

Exception Condition
ArgumentOutOfRangeException

releaseCount è minore di 1.

SemaphoreFullException

Il conteggio del semaforo ha già raggiunto il valore massimo.

IOException

Si è verificato un errore di Win32 con un semaforo denominato.

UnauthorizedAccessException

Il semaforo corrente rappresenta un semaforo di sistema denominato, ma l'utente dispone di SemaphoreRights.Modify diritti.

-oppure-

Il semaforo corrente rappresenta un semaforo di sistema denominato, ma non è stato aperto con SemaphoreRights.Modify diritti.

Se un thread è stato attivato il semaforo più volte, questo overload del metodo consente il conteggio del semaforo intero deve essere ripristinato con una sola chiamata.

Se un SemaphoreFullException viene generata dal Release (metodo), non indica necessariamente un problema con il thread chiamante. Tale thread uscite dal semaforo più volte rispetto agli accessi potrebbe essere causato da un errore di programmazione in un altro thread.

Se l'oggetto corrente Semaphore oggetto rappresenta un semaforo di sistema denominato, l'utente deve disporre SemaphoreRights.Modify diritti e il semaforo deve essere aperto con SemaphoreRights.Modify diritti.

L'esempio di codice seguente viene creato un semaforo con un conteggio massimo di tre e un conteggio iniziale pari a zero. Nell'esempio viene avviato cinque thread, che bloccherà in attesa per il semaforo. Il thread principale utilizza il Release(Int32) overload del metodo per aumentare il conteggio del semaforo al valore massimo, consentendo a tre thread di accedere al semaforo. Ciascun thread utilizza il Thread.Sleep metodo per attendere un secondo, per simulare il funzionamento e quindi chiama il Release() overload del metodo per rilasciare il semaforo.

Ogni volta che il semaforo venga rilasciato, viene visualizzato il conteggio del semaforo precedente. Utilizzo del semaforo traccia messaggi console. L'intervallo di lavoro simulato viene aumentato leggermente per ogni thread, per rendere più semplice leggere l'output.

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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 2.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: