Semaphore Semaphore Semaphore Semaphore Class

Definición

Limita el número de subprocesos que pueden tener acceso a un recurso o grupo de recursos simultáneamente.Limits the number of threads that can access a resource or pool of resources concurrently.

public ref class Semaphore sealed : System::Threading::WaitHandle
[System.Runtime.InteropServices.ComVisible(false)]
public sealed class Semaphore : System.Threading.WaitHandle
type Semaphore = class
    inherit WaitHandle
Public NotInheritable Class Semaphore
Inherits WaitHandle
Herencia
Atributos

Ejemplos

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.The following code example creates a semaphore with a maximum count of three and an initial count of zero. En el ejemplo se inicia cinco subprocesos, que bloquear la espera para el semáforo.The example starts five threads, which block waiting for the semaphore. El subproceso principal utiliza el Release(Int32) sobrecarga del método para aumentar el recuento del semáforo a su máximo, lo que permite tres subprocesos en el semáforo.The main thread uses the Release(Int32) method overload to increase the semaphore count to its maximum, allowing three threads to enter the semaphore. Cada subproceso utiliza el Thread.Sleep método para esperar un segundo, para simular el trabajo y, a continuación, las llamadas a la Release() sobrecarga del método para liberar el semáforo.Each thread uses the Thread.Sleep method to wait for one second, to simulate work, and then calls the Release() method overload to release the semaphore. Cada vez que se libere el semáforo, se muestra el recuento del semáforo anterior.Each time the semaphore is released, the previous semaphore count is displayed. Uso de semáforo pista de la consola mensajes.Console messages track semaphore use. El intervalo de trabajo simulado aumenta ligeramente para que cada subproceso, para facilitar la lectura de la salida.The simulated work interval is increased slightly for each thread, to make the output easier to read.

#using <System.dll>
using namespace System;
using namespace System::Threading;

public ref class Example
{
private:
   // A semaphore that simulates a limited resource pool.
   //
   static Semaphore^ _pool;

   // A padding interval to make the output more orderly.
   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 = gcnew Semaphore( 0,3 );
      
      // Create and start five numbered threads.
      //
      for ( int i = 1; i <= 5; i++ )
      {
         Thread^ t = gcnew Thread(
            gcnew 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( L"Main thread calls Release(3)." );
      _pool->Release( 3 );

      Console::WriteLine( L"Main thread exits." );
   }

private:
   static void Worker( Object^ num )
   {
      // Each worker thread begins by requesting the
      // semaphore.
      Console::WriteLine( L"Thread {0} begins and waits for the semaphore.", num );
      _pool->WaitOne();
      
      // A padding interval to make the output more orderly.
      int padding = Interlocked::Add( _padding, 100 );

      Console::WriteLine( L"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( L"Thread {0} releases the semaphore.", num );
      Console::WriteLine( L"Thread {0} previous semaphore count: {1}",
         num, _pool->Release() );
   }
};
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());
    }
}
Imports System
Imports System.Threading

Public Class Example

    ' A semaphore that simulates a limited resource pool.
    '
    Private Shared _pool As Semaphore

    ' A padding interval to make the output more orderly.
    Private Shared _padding As Integer

    <MTAThread> _
    Public Shared Sub 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 i As Integer = 1 To 5
            Dim t As New Thread(New ParameterizedThreadStart(AddressOf Worker))
            'Dim t As New Thread(AddressOf Worker)

            ' Start the thread, passing the number.
            '
            t.Start(i)
        Next 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.")
    End Sub

    Private Shared Sub Worker(ByVal num As Object)
        ' 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.
        Dim padding As Integer = Interlocked.Add(_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())
    End Sub
End Class

Comentarios

Use la Semaphore clase para controlar el acceso a un grupo de recursos.Use the Semaphore class to control access to a pool of resources. Subprocesos entran el semáforo mediante una llamada a la WaitOne método, que se hereda de la WaitHandle clase y liberar el semáforo mediante una llamada a la Release método.Threads enter the semaphore by calling the WaitOne method, which is inherited from the WaitHandle class, and release the semaphore by calling the Release method.

El recuento de un semáforo es disminuye cada vez que un subproceso entra en el semáforo y se incrementa cuando un subproceso libera el semáforo.The count on a semaphore is decremented each time a thread enters the semaphore, and incremented when a thread releases the semaphore. Cuando el recuento es cero, las solicitudes posteriores se bloquean hasta que otros subprocesos liberan el semáforo.When the count is zero, subsequent requests block until other threads release the semaphore. Cuando todos los subprocesos han liberado el semáforo, el recuento es el valor máximo especificado cuando se creó el semáforo.When all threads have released the semaphore, the count is at the maximum value specified when the semaphore was created.

No hay ningún orden garantizado, como FIFO, LIFO, en el que los subprocesos bloqueados entren en el semáforo.There is no guaranteed order, such as FIFO or LIFO, in which blocked threads enter the semaphore.

Un subproceso puede entrar varias veces, en el semáforo mediante una llamada a la WaitOne método varias veces.A thread can enter the semaphore multiple times, by calling the WaitOne method repeatedly. Para liberar algunas o todas estas entradas, el subproceso puede llamar a sin parámetros Release() sobrecarga del método puede llamar varias veces, o bien el Release(Int32) sobrecarga del método que especifica el número de entradas que se liberan.To release some or all of these entries, the thread can call the parameterless Release() method overload multiple times, or it can call the Release(Int32) method overload that specifies the number of entries to be released.

El Semaphore clase no exige la identidad del subproceso en las llamadas a WaitOne o Release.The Semaphore class does not enforce thread identity on calls to WaitOne or Release. Es responsabilidad del programador asegurarse de que los subprocesos no liberan el semáforo demasiadas veces.It is the programmer's responsibility to ensure that threads do not release the semaphore too many times. Por ejemplo, supongamos que un semáforo tiene un recuento máximo de dos y que los subprocesos A y B entran el semáforo.For example, suppose a semaphore has a maximum count of two, and that thread A and thread B both enter the semaphore. Si un error de programación en el subproceso B hace que llame a Release dos veces, ambas llamadas tendrán éxito.If a programming error in thread B causes it to call Release twice, both calls succeed. El recuento del semáforo está lleno y cuando el subproceso A finalmente llama a Release, se genera SemaphoreFullException.The count on the semaphore is full, and when thread A eventually calls Release, a SemaphoreFullException is thrown.

Son semáforos de dos tipos: semáforos locales y semáforos de sistema con nombre.Semaphores are of two types: local semaphores and named system semaphores. Si creas un Semaphore objeto utilizando un constructor que acepta un nombre, está asociado con un semáforo de sistema operativo de ese nombre.If you create a Semaphore object using a constructor that accepts a name, it is associated with an operating-system semaphore of that name. Los semáforos son visibles en todo el sistema operativo y pueden utilizarse para sincronizar las actividades de procesos de sistema con nombre.Named system semaphores are visible throughout the operating system, and can be used to synchronize the activities of processes. Puede crear varios Semaphore objetos que representan el mismo nombre semáforo del sistema, y puede usar el OpenExisting método para abrir una existente denominado semáforo del sistema.You can create multiple Semaphore objects that represent the same named system semaphore, and you can use the OpenExisting method to open an existing named system semaphore.

Existe un semáforo local solo dentro del proceso.A local semaphore exists only within your process. La puede usar cualquier subproceso del proceso que tenga una referencia al objeto Semaphore local.It can be used by any thread in your process that has a reference to the local Semaphore object. Cada Semaphore objeto es un semáforo local independiente.Each Semaphore object is a separate local semaphore.

Constructores

Semaphore(Int32, Int32) Semaphore(Int32, Int32) Semaphore(Int32, Int32) Semaphore(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.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries.

Semaphore(Int32, Int32, String) Semaphore(Int32, Int32, String) Semaphore(Int32, Int32, String) Semaphore(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, de forma opcional, especifica el nombre de un objeto semáforo del sistema.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries, and optionally specifying the name of a system semaphore object.

Semaphore(Int32, Int32, String, Boolean) Semaphore(Int32, Int32, String, Boolean) Semaphore(Int32, Int32, String, Boolean) Semaphore(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.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries, optionally specifying the name of a system semaphore object, and specifying a variable that receives a value indicating whether a new system semaphore was created.

Semaphore(Int32, Int32, String, Boolean, SemaphoreSecurity) Semaphore(Int32, Int32, String, Boolean, SemaphoreSecurity) Semaphore(Int32, Int32, String, Boolean, SemaphoreSecurity) Semaphore(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.Initializes a new instance of the Semaphore class, specifying the initial number of entries and the maximum number of concurrent entries, optionally specifying the name of a system semaphore object, specifying a variable that receives a value indicating whether a new system semaphore was created, and specifying security access control for the system semaphore.

Métodos

Close() Close() Close() Close()

Libera todos los recursos mantenidos por el objeto WaitHandle actual.Releases all resources held by the current WaitHandle.

(Inherited from WaitHandle)
CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

Libera todos los recursos usados por la instancia actual de la clase WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Inherited from WaitHandle)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Cuando se reemplaza en una clase derivada, libera los recursos no administrados que usa WaitHandle y, de forma opcional, libera los recursos administrados.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Inherited from WaitHandle)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetAccessControl() GetAccessControl() GetAccessControl() GetAccessControl()

Obtiene la seguridad de control de acceso para un semáforo de sistema con nombre.Gets the access control security for a named system semaphore.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del objeto Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Crea una copia superficial del objeto MarshalByRefObject actual.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
OpenExisting(String) OpenExisting(String) OpenExisting(String) OpenExisting(String)

Abre el semáforo con nombre especificado, si ya existe.Opens the specified named semaphore, if it already exists.

OpenExisting(String, SemaphoreRights) OpenExisting(String, SemaphoreRights) OpenExisting(String, SemaphoreRights) OpenExisting(String, SemaphoreRights)

Abre el semáforo con nombre especificado, si ya existe, con el acceso de seguridad deseado.Opens the specified named semaphore, if it already exists, with the desired security access.

Release() Release() Release() Release()

Sale del semáforo y devuelve el recuento anterior.Exits the semaphore and returns the previous count.

Release(Int32) Release(Int32) Release(Int32) Release(Int32)

Sale del semáforo un número especificado de veces y devuelve el recuento anterior.Exits the semaphore a specified number of times and returns the previous count.

SetAccessControl(SemaphoreSecurity) SetAccessControl(SemaphoreSecurity) SetAccessControl(SemaphoreSecurity) SetAccessControl(SemaphoreSecurity)

Establece la seguridad de control de acceso para un semáforo de sistema con nombre.Sets the access control security for a named system semaphore.

ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)
TryOpenExisting(String, Semaphore) TryOpenExisting(String, Semaphore) TryOpenExisting(String, Semaphore) TryOpenExisting(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.Opens the specified named semaphore, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, SemaphoreRights, Semaphore) TryOpenExisting(String, SemaphoreRights, Semaphore) TryOpenExisting(String, SemaphoreRights, Semaphore) TryOpenExisting(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.Opens the specified named semaphore, if it already exists, with the desired security access, and returns a value that indicates whether the operation succeeded.

WaitOne() WaitOne() WaitOne() WaitOne()

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal.Blocks the current thread until the current WaitHandle receives a signal.

(Inherited from WaitHandle)
WaitOne(Int32) WaitOne(Int32) WaitOne(Int32) WaitOne(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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Inherited from WaitHandle)
WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(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.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Inherited from WaitHandle)
WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan)

Bloquea el subproceso actual hasta que la instancia actual recibe una señal, usando TimeSpan para especificar el intervalo de tiempo.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Inherited from WaitHandle)
WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(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.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Inherited from WaitHandle)

Propiedades

Handle Handle Handle Handle

Obtiene o establece el identificador del sistema operativo nativo.Gets or sets the native operating system handle.

(Inherited from WaitHandle)
SafeWaitHandle SafeWaitHandle SafeWaitHandle SafeWaitHandle

Obtiene o establece el identificador del sistema operativo nativo.Gets or sets the native operating system handle.

(Inherited from WaitHandle)

Implementaciones de interfaz explícitas

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Libera todos los recursos que usa WaitHandle.Releases all resources used by the WaitHandle.

(Inherited from WaitHandle)

Campos

WaitTimeout WaitTimeout WaitTimeout WaitTimeout

Indica que una operación WaitAny(WaitHandle[], Int32, Boolean) ha superado el tiempo de espera antes de que se señalara un identificador de espera.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Este campo es constante.This field is constant.

(Inherited from WaitHandle)

Extension Methods

GetAccessControl(Semaphore) GetAccessControl(Semaphore) GetAccessControl(Semaphore) GetAccessControl(Semaphore)
SetAccessControl(Semaphore, SemaphoreSecurity) SetAccessControl(Semaphore, SemaphoreSecurity) SetAccessControl(Semaphore, SemaphoreSecurity) SetAccessControl(Semaphore, SemaphoreSecurity)
GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle)

Obtiene el identificador seguro para un identificador de espera del sistema operativo nativo.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Establece un controlador seguro para un identificador de espera del sistema operativo nativo.Sets a safe handle for a native operating system wait handle.

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.This type is thread safe.

Consulte también: