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

Clase SemaphoreSlim

.NET Framework (current version)
 

Publicado: octubre de 2016

Representa una alternativa ligera a Semaphore que limita el número de subprocesos que puede obtener acceso a la vez a un recurso o a un grupo de recursos.

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

System.Object
  System.Threading.SemaphoreSlim

[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class SemaphoreSlim : IDisposable

NombreDescripción
System_CAPS_pubmethodSemaphoreSlim(Int32)

Inicializa una nueva instancia de la clase SemaphoreSlim, especificando el número inicial de solicitudes que se pueden conceder simultáneamente.

System_CAPS_pubmethodSemaphoreSlim(Int32, Int32)

Inicializa una nueva instancia de la clase SemaphoreSlim, especificando el número inicial y máximo de solicitudes que se pueden conceder simultáneamente.

NombreDescripción
System_CAPS_pubpropertyAvailableWaitHandle

Devuelve un objeto WaitHandle que se puede usar para esperar en el semáforo.

System_CAPS_pubpropertyCurrentCount

Obtiene el número de subprocesos restantes que puede introducir el objeto SemaphoreSlim.

NombreDescripción
System_CAPS_pubmethodDispose()

Libera todos los recursos usados por la instancia actual de la clase SemaphoreSlim.

System_CAPS_protmethodDispose(Boolean)

Libera los recursos no administrados utilizados por el objeto SemaphoreSlim y, de forma opcional, libera los recursos administrados.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_pubmethodRelease()

Libera una vez el objeto SemaphoreSlim.

System_CAPS_pubmethodRelease(Int32)

Libera el objeto SemaphoreSlim un número especificado de veces.

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

System_CAPS_pubmethodWait()

Bloquea el subproceso actual hasta que pueda introducir SemaphoreSlim.

System_CAPS_pubmethodWait(CancellationToken)

Bloquea el subproceso actual hasta que pueda introducir SemaphoreSlim, mientras se observa un elemento CancellationToken.

System_CAPS_pubmethodWait(Int32)

Bloquea el subproceso actual hasta que pueda introducir SemaphoreSlim, usando un entero de 32 bits con signo que especifica el tiempo de espera.

System_CAPS_pubmethodWait(Int32, CancellationToken)

Bloquea el subproceso actual hasta que pueda introducir SemaphoreSlim, usando un entero de 32 bits con signo que especifica el tiempo de espera mientras se observa un elemento CancellationToken.

System_CAPS_pubmethodWait(TimeSpan)

Bloquea el subproceso actual hasta que pueda introducir SemaphoreSlim, usando TimeSpan para especificar el tiempo de espera.

System_CAPS_pubmethodWait(TimeSpan, CancellationToken)

Bloquea el subproceso actual hasta que pueda introducir SemaphoreSlim, usando un TimeSpan que especifica el tiempo de espera mientras se observa un elemento CancellationToken.

System_CAPS_pubmethodWaitAsync()

De forma asincrónica espera que se introduzca SemaphoreSlim.

System_CAPS_pubmethodWaitAsync(CancellationToken)

De forma asincrónica, espera introducir SemaphoreSlim, mientras observa un elemento CancellationToken.

System_CAPS_pubmethodWaitAsync(Int32)

De forma asincrónica espera que se introduzca SemaphoreSlim, usando un entero de 32 bits para medir el intervalo de tiempo.

System_CAPS_pubmethodWaitAsync(Int32, CancellationToken)

De forma asincrónica, espera introducir SemaphoreSlim, usando un entero de 32 bits para medir el intervalo de tiempo, mientras observa un elemento CancellationToken.

System_CAPS_pubmethodWaitAsync(TimeSpan)

De forma asincrónica, espera introducir SemaphoreSlim, usando un TimeSpan para medir el intervalo de tiempo.

System_CAPS_pubmethodWaitAsync(TimeSpan, CancellationToken)

De forma asincrónica, espera introducir SemaphoreSlim, usando un TimeSpan para medir el intervalo de tiempo, mientras observa un elemento CancellationToken.

Los semáforos son de dos tipos: semáforos locales y semáforos de sistema con nombre. El primero es local a una aplicación. El último es visible en el sistema operativo y es adecuado para la sincronización entre proceso. El SemaphoreSlim es una alternativa ligera a la Semaphore clase que no utiliza los semáforos de kernel de Windows. A diferencia de la Semaphore (clase), el SemaphoreSlim clase no es compatible con los semáforos de sistema con nombre. Puede usarlo como un semáforo local únicamente. La SemaphoreSlim clase es el semáforo recomendado para la sincronización en una sola aplicación.

Un semáforo ligero controla el acceso a un grupo de recursos local de la aplicación. Cuando crea una instancia de un semáforo, puede especificar el número máximo de subprocesos que pueden entrar en el semáforo simultáneamente. También especifica el número inicial de subprocesos que pueden entrar en el semáforo simultáneamente. Esto define el recuento del semáforo.

El recuento se reduce cada vez que un subproceso entra en el semáforo, e incrementa cada vez que un subproceso libera el semáforo. Para entrar en el semáforo, un subproceso llama a uno de los Wait o WaitAsync sobrecargas. Para liberar el semáforo, llama a uno de los Release sobrecargas. Cuando el recuento llega a cero, las llamadas subsiguientes a uno de los Wait métodos se bloquean hasta que otros subprocesos liberan el semáforo. Si varios subprocesos se bloquean, no hay ningún orden garantizado, como FIFO o LIFO, que controla si los subprocesos entran en el semáforo.

La estructura básica para el código que utiliza un semáforo para proteger los recursos es:


' Enter semaphore by calling one of the Wait or WaitAsync methods.
SemaphoreSlim.Wait()
' 
' Execute code protected by the semaphore. 
'
SemaphoreSlim.Release()

Cuando todos los subprocesos han liberado el semáforo, el recuento es el valor máximo especificado cuando se creó el semáforo. El recuento del semáforo está disponible desde el CurrentCount propiedad.

System_CAPS_importantImportante

La SemaphoreSlim clase no exige la identidad del subproceso o tarea en las llamadas a la Wait, WaitAsync, y Release métodos. Además, si la SemaphoreSlim(Int32) constructor se utiliza para crear una instancia de la SemaphoreSlim objeto, el CurrentCount puede aumentar la propiedad por encima del valor establecido por el constructor. Es responsabilidad del programador asegurarse de que las llamadas a Wait o WaitAsync métodos están emparejados correctamente con llamadas a Release métodos.

En el ejemplo siguiente se crea un semáforo con un número máximo de tres subprocesos y un recuento inicial de cero subprocesos. El ejemplo inicia cinco tareas, todos los cuales bloquean la espera del semáforo. El subproceso principal llama el Release(Int32) sobrecarga para aumentar el recuento del semáforo a su máximo, que permite que las tres tareas entrar en 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 facilitar la lectura de la salida.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
    private static SemaphoreSlim semaphore;
    // A padding interval to make the output more orderly.
    private static int padding;

    public static void Main()
    {
        // Create the semaphore.
        semaphore = new SemaphoreSlim(0, 3);
        Console.WriteLine("{0} tasks can enter the semaphore.",
                          semaphore.CurrentCount);
        Task[] tasks = new Task[5];

        // Create and start five numbered tasks.
        for(int i = 0; i <= 4; i++)
        {
            tasks[i] = Task.Run( () => {
            // Each task begins by requesting the semaphore.
            Console.WriteLine("Task {0} begins and waits for the semaphore.",
                              Task.CurrentId);
            semaphore.Wait();

            Interlocked.Add(ref padding, 100);

            Console.WriteLine("Task {0} enters the semaphore.", Task.CurrentId);

            // The task just sleeps for 1+ seconds.
            Thread.Sleep(1000 + padding);

            Console.WriteLine("Task {0} releases the semaphore; previous count: {1}.",
                              Task.CurrentId, semaphore.Release()); } );
        }

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

        // Restore the semaphore count to its maximum value.
        Console.Write("Main thread calls Release(3) --> ");
        semaphore.Release(3);
        Console.WriteLine("{0} tasks can enter the semaphore.",
                          semaphore.CurrentCount);
        // Main thread waits for the tasks to complete.
        Task.WaitAll(tasks);

        Console.WriteLine("Main thread exits.");
    }
}
// The example displays output like the following:
//       0 tasks can enter the semaphore.
//       Task 1 begins and waits for the semaphore.
//       Task 5 begins and waits for the semaphore.
//       Task 2 begins and waits for the semaphore.
//       Task 4 begins and waits for the semaphore.
//       Task 3 begins and waits for the semaphore.
//       Main thread calls Release(3) --> 3 tasks can enter the semaphore.
//       Task 4 enters the semaphore.
//       Task 1 enters the semaphore.
//       Task 3 enters the semaphore.
//       Task 4 releases the semaphore; previous count: 0.
//       Task 2 enters the semaphore.
//       Task 1 releases the semaphore; previous count: 0.
//       Task 3 releases the semaphore; previous count: 0.
//       Task 5 enters the semaphore.
//       Task 2 releases the semaphore; previous count: 1.
//       Task 5 releases the semaphore; previous count: 2.
//       Main thread exits.

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 4.0
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Windows Phone Silverlight
Disponible desde 8.0
Windows Phone
Disponible desde 8.1

Todos los miembros públicos y protegidos de SemaphoreSlim son seguros para subprocesos y se pueden usar simultáneamente desde varios subprocesos, con la excepción de Dispose, que se debe utilizar solo cuando todas las operaciones en el SemaphoreSlim completado.

Volver al principio
Mostrar: