Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Semaphore.Release (Método)

Sale del semáforo y devuelve el recuento anterior.

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

public int Release()

Valor devuelto

Tipo: System.Int32
El recuento en el semáforo antes de la llamada al método Release.

ExcepciónCondición
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.

O bien

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

Los subprocesos normalmente utilizan el método WaitOne para entrar en el semáforo y esta sobrecarga del método para salir.

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

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

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 aumenta el recuento del semáforo a su máximo, mediante la sobrecarga del método Release(Int32), lo que permite la entrada de tres subprocesos en el semáforo. Los subprocesos utilizan el método Thread.Sleep para esperar un segundo, simular que trabajan y, a continuación, llamar a la sobrecarga de método Release() para liberar el semáforo.

Cada vez que se libera el semáforo, se muestra el recuento del semáforo anterior. Los mensajes de consola llevan un seguimiento del uso del semáforo. El intervalo de trabajo simulado aumenta ligeramente por cada subproceso, lo que facilita la lectura del resultado.


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


.NET Framework

Compatible con: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft