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 Semaphore

 

Publicado: octubre de 2016

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)

System.Object
  System.MarshalByRefObject
    System.Threading.WaitHandle
      System.Threading.Semaphore

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

NombreDescripción
System_CAPS_pubmethodSemaphore(Int32, Int32)

Inicializa una nueva instancia de la clase Semaphore, que especifica el número inicial de entradas y el número máximo de entradas simultáneas.

System_CAPS_pubmethodSemaphore(Int32, Int32, String)

Inicializa una nueva instancia de la clase Semaphore, que especifica el número inicial de entradas y el número máximo de entradas simultáneas, y especificando de forma opcional el nombre de un objeto semáforo de sistema.

System_CAPS_pubmethodSemaphore(Int32, Int32, String, Boolean)

Inicializa una instancia nueva de la clase Semaphore, especificando el número inicial de entradas y el número máximo de entradas simultáneas, 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 creó un semáforo del sistema nuevo.

System_CAPS_pubmethodSemaphore(Int32, Int32, String, Boolean, SemaphoreSecurity)

Inicializa una instancia nueva de la clase Semaphore, especificando el número inicial de entradas y el número máximo de entradas simultáneas, 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 del sistema y especificando la seguridad de control de acceso para el semáforo del sistema.

NombreDescripción
System_CAPS_pubpropertyHandle

Obsoleto. Obtiene o establece el identificador del sistema operativo nativo.(Heredado de WaitHandle).

System_CAPS_pubpropertySafeWaitHandle

Obtiene o establece el identificador del sistema operativo nativo.(Heredado de WaitHandle).

NombreDescripción
System_CAPS_pubmethodClose()

Libera todos los recursos mantenidos por el objeto WaitHandle actual.(Heredado de WaitHandle).

System_CAPS_pubmethodCreateObjRef(Type)

Crea un objeto que contiene toda la información relevante necesaria para generar a un proxy que se utiliza para comunicarse con un objeto remoto.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodDispose()

Libera todos los recursos usados por la instancia actual de la clase WaitHandle.(Heredado de WaitHandle).

System_CAPS_pubmethodEquals(Object)

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

System_CAPS_pubmethodGetAccessControl()

Obtiene la seguridad de control de acceso para un semáforo de sistema con nombre.

System_CAPS_pubmethodGetHashCode()

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

System_CAPS_pubmethodGetLifetimeService()

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodGetType()

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

System_CAPS_pubmethodInitializeLifetimeService()

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String)

Abre el semáforo con nombre especificado, si ya existe.

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String, SemaphoreRights)

Abre el semáforo con nombre especificado, si ya existe, con el acceso de seguridad deseado.

System_CAPS_pubmethodRelease()

Sale del semáforo y devuelve el recuento anterior.

System_CAPS_pubmethodRelease(Int32)

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

System_CAPS_pubmethodSetAccessControl(SemaphoreSecurity)

Establece la seguridad de control de acceso para un semáforo de sistema con nombre.

System_CAPS_pubmethodToString()

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

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(String, Semaphore)

Abre el semáforo con nombre especificado, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente.

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(String, SemaphoreRights, Semaphore)

Abre el semáforo con nombre especificado, si ya existe, con el acceso de seguridad deseado, y devuelve un valor que indica si la operación se realizó correctamente.

System_CAPS_pubmethodWaitOne()

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal.(Heredado de WaitHandle).

System_CAPS_pubmethodWaitOne(Int32)

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, usando un entero de 32 bits con signo para especificar el intervalo de tiempo en milisegundos.(Heredado de WaitHandle).

System_CAPS_pubmethodWaitOne(Int32, Boolean)

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, usa un entero de 32 bits con signo para determinar el intervalo de tiempo y especifica si hay que salir del dominio de sincronización antes de la espera.(Heredado de WaitHandle).

System_CAPS_pubmethodWaitOne(TimeSpan)

Bloquea el subproceso actual hasta que la instancia actual recibe una señal, usando TimeSpan para especificar el intervalo de tiempo.(Heredado de WaitHandle).

System_CAPS_pubmethodWaitOne(TimeSpan, Boolean)

Bloquea el subproceso actual hasta que la instancia actual recibe una señal; usa TimeSpan para determinar el intervalo de tiempo y especifica si hay que abandonar el dominio de sincronización antes de la espera.(Heredado de WaitHandle).

NombreDescripción
System_CAPS_pubmethodGetSafeWaitHandle()

Obtiene el identificador seguro para un identificador de espera del sistema operativo nativo.(Definido por WaitHandleExtensions).

System_CAPS_pubmethodSetSafeWaitHandle(SafeWaitHandle)

Establece un controlador seguro para un identificador de espera del sistema operativo nativo.(Definido por WaitHandleExtensions).

Use the T:System.Threading.Semaphore class to control access to a pool of resources. Threads enter the semaphore by calling the Overload:System.Threading.WaitHandle.WaitOne method, which is inherited from the T:System.Threading.WaitHandle class, and release the semaphore by calling the Overload:System.Threading.Semaphore.Release method.

The count on a semaphore is decremented each time a thread enters the semaphore, and incremented when a thread releases the semaphore. When the count is zero, subsequent requests block until other threads release the semaphore. When all threads have released the semaphore, the count is at the maximum value specified when the semaphore was created.

There is no guaranteed order, such as FIFO or LIFO, in which blocked threads enter the semaphore.

A thread can enter the semaphore multiple times, by calling the Overload:System.Threading.WaitHandle.WaitOne method repeatedly. To release some or all of these entries, the thread can call the parameterless M:System.Threading.Semaphore.Release method overload multiple times, or it can call the M:System.Threading.Semaphore.Release(System.Int32) method overload that specifies the number of entries to be released.

The T:System.Threading.Semaphore class does not enforce thread identity on calls to Overload:System.Threading.WaitHandle.WaitOne or Overload:System.Threading.Semaphore.Release. It is the programmer's responsibility to ensure that threads do not release the semaphore too many times. For example, suppose a semaphore has a maximum count of two, and that thread A and thread B both enter the semaphore. If a programming error in thread B causes it to call Overload:System.Threading.Semaphore.Release twice, both calls succeed. The count on the semaphore is full, and when thread A eventually calls Overload:System.Threading.Semaphore.Release, a T:System.Threading.SemaphoreFullException is thrown.

Semaphores are of two types: local semaphores and named system semaphores. If you create a T:System.Threading.Semaphore object using a constructor that accepts a name, it is associated with an operating-system semaphore of that name. Named system semaphores are visible throughout the operating system, and can be used to synchronize the activities of processes. You can create multiple T:System.Threading.Semaphore objects that represent the same named system semaphore, and you can use the Overload:System.Threading.Semaphore.OpenExisting method to open an existing named system semaphore.

A local semaphore exists only within your process. It can be used by any thread in your process that has a reference to the local T:System.Threading.Semaphore object. Each T:System.Threading.Semaphore object is a separate local semaphore.

The following code example creates a semaphore with a maximum count of three and an initial count of zero. The example starts five threads, which block waiting for the semaphore. The main thread uses the M:System.Threading.Semaphore.Release(System.Int32) method overload to increase the semaphore count to its maximum, allowing three threads to enter the semaphore. Each thread uses the Overload:System.Threading.Thread.Sleep method to wait for one second, to simulate work, and then calls the M:System.Threading.Semaphore.Release method overload to release the semaphore. Each time the semaphore is released, the previous semaphore count is displayed. Console messages track semaphore use. The simulated work interval is increased slightly for each thread, to make the output easier to read.

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

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 2.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

This type is thread safe.

Volver al principio
Mostrar: