Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Semaphore.Release (Método) (Int32)

 

Sale del semáforo un número especificado de veces y devuelve el recuento anterior.

Espacio de nombres:   System.Threading
Ensamblado:  System (en System.dll)

public int Release(
	int releaseCount
)

Parámetros

releaseCount

Número de veces que se abandona el semáforo.

Valor devuelto

Type: System.Int32

Recuento en el semáforo antes de la llamada al método Release.

Exception Condition
ArgumentOutOfRangeException

releaseCount es menor que 1.

SemaphoreFullException

El recuento del semáforo ya está en el valor máximo.

IOException

Error de Win32 con un semáforo con nombre.

UnauthorizedAccessException

El semáforo actual representa un semáforo de sistema con nombre, pero el usuario no tiene SemaphoreRights.Modify derechos.

-o-

El semáforo actual representa un semáforo de sistema con nombre, pero no se abrió con SemaphoreRights.Modify derechos.

Si un subproceso ha entrado varias veces en el semáforo, esta sobrecarga del método permite el recuento del semáforo completo restaurarse con una llamada.

Si una SemaphoreFullException producida por la Release método, no indica necesariamente un problema con el subproceso de llamada.Un error de programación en otro subproceso podría haber causado ese subproceso salga del semáforo más veces de las que entró.

Si la corriente Semaphore objeto representa un semáforo de sistema con nombre, el usuario debe tener SemaphoreRights.Modify derechos y el semáforo se deben haber abierto con SemaphoreRights.Modify derechos.

En el ejemplo de código siguiente se crea un semáforo con un número máximo de tres y un recuento inicial de cero.El ejemplo inicia cinco subprocesos que se bloquean en espera del semáforo.El subproceso principal utiliza el Release(Int32) sobrecarga del método para incrementar el recuento del semáforo a su máximo, lo que permite tres subprocesos en el semáforo.Cada subproceso utiliza el Thread.Sleep método para esperar un segundo, para simular el trabajo y, a continuación, llama a la Release() sobrecarga del método para liberar el semáforo.

Cada vez que se libera el semáforo, se muestra el recuento del semáforo anterior.Uso del semáforo de seguimiento de consola mensajes.El intervalo de trabajo simulado aumenta ligeramente por cada subproceso, para facilitar la lectura de la salida.

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
Disponible desde 4.5
.NET Framework
Disponible desde 2.0
Portable Class Library
Compatible con: portable .NET platforms
Windows Phone Silverlight
Disponible desde 8.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: