SemaphoreFullException Clase

Definición

Espacio de nombres:

System.Threading

Ensamblado:

System.Threading.dll

Ensamblado:

System.dll

Ensamblado:

mscorlib.dll

Ensamblado:

netstandard.dll

Excepción que se produce cuando se llama al método Release en un semáforo cuyo recuento ya se encuentra en el máximo.

public ref class SemaphoreFullException : Exception

public ref class SemaphoreFullException : SystemException

public class SemaphoreFullException : Exception

public class SemaphoreFullException : SystemException

[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class SemaphoreFullException : SystemException

type SemaphoreFullException = class
    inherit Exception

type SemaphoreFullException = class
    inherit SystemException

[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type SemaphoreFullException = class
    inherit SystemException

Public Class SemaphoreFullException
Inherits Exception

Public Class SemaphoreFullException
Inherits SystemException

Herencia

Object

Exception

SemaphoreFullException

Herencia

Object

Exception

SystemException

SemaphoreFullException

Atributos

ComVisibleAttribute SerializableAttribute

Ejemplos

En el ejemplo de código siguiente se muestra cómo un error de programación en un subproceso puede provocar un SemaphoreFullException en otro subproceso: dos subprocesos entran en un semáforo. El segundo subproceso libera el semáforo dos veces, mientras que el primer subproceso sigue ejecutando su tarea. Cuando el primer subproceso finaliza y libera el semáforo, el recuento de semáforos ya está lleno y se produce una excepción.

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

public ref class Example
{
private:
   // A semaphore that can satisfy at most two concurrent
   // requests.
   //
   static Semaphore^ _pool = gcnew Semaphore( 2,2 );

public:
   static void main()
   {
      // Create and start two threads, A and B.
      //
      Thread^ tA = gcnew Thread( gcnew ThreadStart( ThreadA ) );
      tA->Start();

      Thread^ tB = gcnew Thread( gcnew ThreadStart( ThreadB ) );
      tB->Start();
   }

private:
   static void ThreadA()
   {
      // Thread A enters the semaphore and simulates a task
      // that lasts a second.
      //
      _pool->WaitOne();
      Console::WriteLine( L"Thread A entered the semaphore." );

      Thread::Sleep( 1000 );

      try
      {
         _pool->Release();
         Console::WriteLine( L"Thread A released the semaphore." );
      }
      catch ( Exception^ ex ) 
      {
         Console::WriteLine( L"Thread A: {0}", ex->Message );
      }
   }

   static void ThreadB()
   {
      // Thread B simulates a task that lasts half a second,
      // then enters the semaphore.
      //
      Thread::Sleep( 500 );

      _pool->WaitOne();
      Console::WriteLine( L"Thread B entered the semaphore." );
      
      // Due to a programming error, Thread B releases the
      // semaphore twice. To fix the program, delete one line.
      _pool->Release();
      _pool->Release();
      Console::WriteLine( L"Thread B exits successfully." );
   }
};
/* This code example produces the following output:

Thread A entered the semaphore.
Thread B entered the semaphore.
Thread B exits successfully.
Thread A: Adding the given count to the semaphore would cause it to exceed its maximum count.
 */

using System;
using System.Threading;

public class Example
{
    // A semaphore that can satisfy at most two concurrent
    // requests.
    //
    private static Semaphore _pool = new Semaphore(2, 2);

    public static void Main()
    {
        // Create and start two threads, A and B. 
        //
        Thread tA = new Thread(new ThreadStart(ThreadA));
        tA.Start();

        Thread tB = new Thread(new ThreadStart(ThreadB));
        tB.Start();
    }

    private static void ThreadA()
    {
        // Thread A enters the semaphore and simulates a task
        // that lasts a second.
        //
        _pool.WaitOne();
        Console.WriteLine("Thread A entered the semaphore.");

        Thread.Sleep(1000);

        try
        {
            _pool.Release();
            Console.WriteLine("Thread A released the semaphore.");
        }
        catch(Exception ex)
        {
            Console.WriteLine("Thread A: {0}", ex.Message);
        }
    }

    private static void ThreadB()
    {
        // Thread B simulates a task that lasts half a second,
        // then enters the semaphore.
        //
        Thread.Sleep(500);

        _pool.WaitOne();
        Console.WriteLine("Thread B entered the semaphore.");
        
        // Due to a programming error, Thread B releases the
        // semaphore twice. To fix the program, delete one line.
        _pool.Release();
        _pool.Release();
        Console.WriteLine("Thread B exits successfully.");
    }
}
/* This code example produces the following output:

Thread A entered the semaphore.
Thread B entered the semaphore.
Thread B exits successfully.
Thread A: Adding the given count to the semaphore would cause it to exceed its maximum count.
 */

Imports System.Threading

Public Class Example

    ' A semaphore that can satisfy at most two concurrent
    ' requests.
    '
    Private Shared _pool As New Semaphore(2, 2)

    <MTAThread> _
    Public Shared Sub Main()
        ' Create and start two threads, A and B. 
        '
        Dim tA As New Thread(AddressOf ThreadA)
        tA.Start()

        Dim tB As New Thread(AddressOf ThreadB)
        tB.Start()

    End Sub

    Private Shared Sub ThreadA()
        ' Thread A enters the semaphore and simulates a task
        ' that lasts a second.
        '
        _pool.WaitOne()
        Console.WriteLine("Thread A entered the semaphore.")

        Thread.Sleep(1000)

        Try
            _pool.Release()
            Console.WriteLine("Thread A released the semaphore.")
        Catch ex As Exception
            Console.WriteLine("Thread A: {0}", ex.Message)
        End Try
    End Sub

    Private Shared Sub ThreadB()
        ' Thread B simulates a task that lasts half a second,
        ' then enters the semaphore.
        '
        Thread.Sleep(500)

        _pool.WaitOne()
        Console.WriteLine("Thread B entered the semaphore.")
        
        ' Due to a programming error, Thread B releases the
        ' semaphore twice. To fix the program, delete one line.
        _pool.Release()
        _pool.Release()
        Console.WriteLine("Thread B exits successfully.")
    End Sub
End Class
' This code example produces the following output:
'
' Thread A entered the semaphore.
' Thread B entered the semaphore.
' Thread B exits successfully.
' Thread A: Adding the given count to the semaphore would cause it to exceed its maximum count.
'

Comentarios

El recuento de un semáforo se disminuye cada vez que un subproceso entra en el semáforo e incrementa 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 se encuentra en el valor máximo especificado cuando se creó el semáforo. Si un error de programación hace que un subproceso llame al Semaphore.Release método en este momento, se produce una SemaphoreFullException excepción .

Nota

La Semaphore clase no aplica la identidad del subproceso en las llamadas a los WaitHandle.WaitOne métodos y Semaphore.Release . No es necesario para el mismo subproceso al que llamó WaitOne para llamar Releasea .

SemaphoreFullException no indica necesariamente un problema con el código en el que se produjo la excepción. Considere el siguiente escenario: El subproceso A y el subproceso B especifican un semáforo que tiene un recuento máximo de dos. Un error de programación en el subproceso B hace que llame Release dos veces, de modo que el recuento del semáforo esté lleno. Como resultado, cuando el subproceso A llama finalmente a Release, se produce una SemaphoreFullException excepción .

Para obtener una lista con los valores de propiedad iniciales de una instancia de la clase SemaphoreFullException, vea el constructor SemaphoreFullException().

Constructores

SemaphoreFullException()	Inicializa una nueva instancia de la clase SemaphoreFullException con valores predeterminados.
SemaphoreFullException(SerializationInfo, StreamingContext)	Inicializa una nueva instancia de la clase SemaphoreFullException con datos serializados.
SemaphoreFullException(String)	Inicializa una nueva instancia de la clase SemaphoreFullException con el mensaje de error especificado.
SemaphoreFullException(String, Exception)	Inicializa una nueva instancia de la clase SemaphoreFullException con el mensaje de error especificado y una referencia a la excepción interna que representa la causa de esta excepción.

Propiedades

Data	Obtiene una colección de pares clave/valor que proporciona información definida por el usuario adicional sobre la excepción. (Heredado de Exception)
HelpLink	Obtiene o establece un vínculo al archivo de ayuda asociado a esta excepción. (Heredado de Exception)
HResult	Obtiene o establece HRESULT, un valor numérico codificado que se asigna a una excepción específica. (Heredado de Exception)
InnerException	Obtiene la instancia Exception que produjo la excepción actual. (Heredado de Exception)
Message	Obtiene un mensaje que describe la excepción actual. (Heredado de Exception)
Source	Devuelve o establece el nombre de la aplicación o del objeto que generó el error. (Heredado de Exception)
StackTrace	Obtiene una representación de cadena de los marcos inmediatos en la pila de llamadas. (Heredado de Exception)
TargetSite	Obtiene el método que produjo la excepción actual. (Heredado de Exception)

Métodos

Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetBaseException()	Cuando se invalida en una clase derivada, devuelve la clase Exception que representa la causa principal de una o más excepciones posteriores. (Heredado de Exception)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetObjectData(SerializationInfo, StreamingContext)	Cuando se invalida en una clase derivada, establece SerializationInfo con información sobre la excepción. (Heredado de Exception)
GetType()	Obtiene el tipo de tiempo de ejecución de la instancia actual. (Heredado de Exception)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ToString()	Crea y devuelve una representación de cadena de la excepción actual. (Heredado de Exception)

Eventos

SerializeObjectState

Obsoletos. Ocurre cuando una excepción se serializa para crear un objeto de estado de excepción que contenga datos serializados sobre la excepción. (Heredado de Exception)

Consulte también

• Semaphore
• Semaphore