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 (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úblicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsSemaphore(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úblicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsSemaphore(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úblicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsSemaphore(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úblicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsDispose()Libera todos los recursos usados por la instancia actual de la clase WaitHandle. (Se hereda de WaitHandle).
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsEquals(Object)Determina si el objeto especificado es igual al objeto actual. (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úblicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetHashCode Sirve como una función hash para un tipo en particular. (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úblicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsGetType 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 públicoMiembro estáticoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsOpenExisting(String)Abra el semáforo especificado, si existe.
Método públicoMiembro estáticoOpenExisting(String, SemaphoreRights)Abra el semáforo especificado, si ya existe, con acceso deseado de seguridad.
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsRelease()Sale del semáforo y devuelve el recuento anterior.
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsRelease(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úblicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Método públicoMiembro estáticoCompatible con .NET para aplicaciones de la Tienda WindowsTryOpenExisting(String, Semaphore)Abra el semáforo especificado, si existe, y devuelve un valor que indica si la operación se realizó correctamente.
Método públicoMiembro estáticoTryOpenExisting(String, SemaphoreRights, Semaphore)Abra el semáforo especificado, si ya existe, con acceso deseado de seguridad, y devuelve un valor que indica si la operación se realizó correctamente.
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsWaitOne()Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal. (Se hereda de WaitHandle).
Método públicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsWaitOne(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úblicoCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsWaitOne(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 el semáforo y aumenta cuando un subproceso libera el semáforo. 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 alcanza el valor máximo que se especificó 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, imagine un semáforo que tiene un recuento máximo de dos y en el que entran un subproceso A y un subproceso B. Si un error de programación del subproceso B hace que llame a Release dos veces, las dos llamadas tienen éxito. El recuento del semáforo está completo y cuando finalmente el subproceso A llama al método Release, se produce 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 utilizarla cualquier subproceso del proceso que tenga 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 valor de propiedad Resources siguiente: 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.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.

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

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft