¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
Semaphore (Clase)
Collapse the table of content
Expand the table of content
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original

Semaphore (Clase)

Limita el número de subprocesos que pueden tener acceso a un recurso o grupo de recursos simultáneamente.

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

[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public sealed class Semaphore : WaitHandle

El tipo Semaphore expone los siguientes miembros.

  NombreDescripción
Método públicoSemaphore(Int32, Int32)Inicializa una instancia nueva de la clase Semaphore, que especifica el número máximo de entradas simultáneas y, de forma opcional, reserva algunas entradas.
Método públicoSemaphore(Int32, Int32, String)Inicializa una instancia nueva de la clase Semaphore, que especifica el número máximo de entradas simultáneas, reservando opcionalmente algunas entradas para el subproceso que hace la llamada, y especificando de forma opcional el nombre de un objeto semáforo de sistema.
Método públicoSemaphore(Int32, Int32, String, Boolean)Inicializa una instancia nueva de la clase Semaphore, especificando el número máximo de entradas simultáneas, reservando opcionalmente algunas entradas para el subproceso que realiza la llamada, especificando de forma opcional el nombre de un objeto semáforo de sistema y especificando una variable que recibe un valor que indica si se crea un semáforo de sistema nuevo.
Método públicoSemaphore(Int32, Int32, String, Boolean, SemaphoreSecurity)Inicializa una instancia nueva de la clase Semaphore, especificando el número máximo de entradas simultáneas, reservando opcionalmente algunas entradas para el subproceso que realiza la llamada, especificando de forma opcional el nombre de un objeto semáforo de sistema, especificando una variable que recibe un valor que indica si se creó un semáforo de sistema y especificando la seguridad de control de acceso para el semáforo de sistema.
Arriba

  NombreDescripción
Propiedad públicaHandle Obsoleto. Obtiene o establece el identificador del sistema operativo nativo. (Se hereda de WaitHandle).
Propiedad públicaSafeWaitHandleObtiene o establece el identificador del sistema operativo nativo. (Se hereda de WaitHandle).
Arriba

  NombreDescripción
Método públicoClose Cuando se sobrescribe en una clase derivada, libera todos los recursos mantenidos por el WaitHandle actual. (Se hereda de WaitHandle).
Método públicoCreateObjRefCrea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Se hereda de MarshalByRefObject).
Método públicoDispose()Libera todos los recursos usados por la instancia actual de la clase WaitHandle. (Se hereda de WaitHandle).
Método protegidoDispose(Boolean)Cuando se reemplaza en una clase derivada, libera los recursos no administrados utilizados por WaitHandle y, de forma opcional, libera los recursos administrados. (Se hereda de WaitHandle).
Método públicoEquals(Object)Determina si el objeto Object especificado es igual al objeto Object actual. (Se hereda de Object).
Método protegidoFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método públicoGetAccessControlObtiene la seguridad de control de acceso para un semáforo de sistema con nombre.
Método públicoGetHashCodeActúa como función hash para un tipo concreto. (Se hereda de Object).
Método públicoGetLifetimeServiceRecupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoInitializeLifetimeServiceObtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método protegidoMemberwiseClone() Crea una copia superficial del Object actual. (Se hereda de Object).
Método protegidoMemberwiseClone(Boolean)Crea una copia superficial del objeto MarshalByRefObject actual. (Se hereda de MarshalByRefObject).
Método públicoMiembro estáticoOpenExisting(String)Abre un semáforo con nombre existente.
Método públicoMiembro estáticoOpenExisting(String, SemaphoreRights)Abre un semáforo con nombre existente, especificando los derechos de acceso de seguridad deseados.
Método públicoRelease()Sale del semáforo y devuelve el recuento anterior.
Método públicoRelease(Int32)Sale del semáforo un número especificado de veces y devuelve el recuento anterior.
Método públicoSetAccessControlEstablece la seguridad de control de acceso para un semáforo de sistema con nombre.
Método públicoToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Método públicoWaitOne()Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal. (Se hereda de WaitHandle).
Método públicoWaitOne(Int32)Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo. (Se hereda de WaitHandle).
Método públicoWaitOne(TimeSpan)Bloquea el subproceso actual hasta que la instancia actual recibe una señal, utilizando TimeSpan para especificar el intervalo de tiempo. (Se hereda de WaitHandle).
Método públicoWaitOne(Int32, Boolean)Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, utilizando un entero de 32 bits con signo para especificar el intervalo de tiempo y especificando si hay que salir del dominio de sincronización antes de la espera. (Se hereda de WaitHandle).
Método públicoWaitOne(TimeSpan, Boolean)Bloquea el subproceso actual hasta que la instancia actual recibe una señal, utilizando TimeSpan para especificar el intervalo de tiempo y especificando si hay que abandonar el dominio de sincronización antes de la espera. (Se hereda de WaitHandle).
Arriba

Utilice la clase Semaphore para controlar el acceso a un grupo de recursos. Para entrar en el semáforo, los subprocesos llaman al método WaitOne, que se hereda de la clase WaitHandle, y para liberarlo llaman al método Release.

El recuento de un semáforo disminuye cada vez que un subproceso entra en él, e incrementa cuando un subproceso lo libera. Cuando el recuento es cero, las solicitudes posteriores se bloquean hasta que otros subprocesos liberan el semáforo. Cuando todos los subprocesos han liberado el semáforo, el recuento está en el valor máximo especificado al crear el semáforo.

No hay ningún orden garantizado, como FIFO o LIFO, para la entrada de los subprocesos bloqueados en el semáforo.

Un subproceso puede entrar varias veces en el semáforo, mediante llamadas al método WaitOne. Para liberar algunas de estas entradas o todas ellas, el subproceso puede llamar varias veces a la sobrecarga del método Release() sin parámetros, o bien a la sobrecarga del método Release(Int32), que especifica el número de entradas que se liberan.

La clase Semaphore no exige la identidad del subproceso en las llamadas a WaitOne o Release. Es responsabilidad del programador garantizar que los subprocesos no liberen el semáforo demasiadas veces. Por ejemplo, supongamos que un semáforo tiene un recuento máximo de dos y que entran en el semáforo los subprocesos A y B. Si un error de programación del subproceso B hace que llame a Release dos veces, las dos llamadas tienen éxito. Se alcanza el recuento máximo del semáforo y, si el subproceso A llama posteriormente a Release, se genera una excepción SemaphoreFullException.

Los semáforos son de dos tipos: semáforos locales y semáforos de sistema con nombre. Si crea un objeto Semaphore mediante un constructor que acepta un nombre, se asocia a un semáforo del sistema operativo con ese nombre. Los semáforos de sistema con nombre son visibles en todo el sistema operativo y se pueden utilizar para sincronizar las actividades de los procesos. Puede crear varios objetos Semaphore que representan el mismo semáforo de sistema con nombre y, para abrir un semáforo de sistema con nombre ya existente, puede utilizar el método OpenExisting.

Un semáforo local sólo existe dentro del proceso. Puede utilizarlo cualquier subproceso del proceso que contenga una referencia al objeto Semaphore local. Cada objeto Semaphore es un semáforo local distinto.

NotaNota

El atributo HostProtectionAttribute aplicado a este tipo o miembro tiene el siguiente valor de la propiedad Resources: Synchronization | ExternalThreading. El atributo HostProtectionAttribute no afecta a las aplicaciones de escritorio (que normalmente se inician haciendo doble clic en un icono, escribiendo un comando o introduciendo una dirección URL en el explorador). Para obtener más información, vea la clase HostProtectionAttribute o Programación en SQL Server y atributos de protección de host.

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, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.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.

Este tipo es seguro para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft