SemaphoreFullException Clase

Definición

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.The exception that is thrown when the Release method is called on a semaphore whose count is already at the maximum.

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
SemaphoreFullException
Herencia
SemaphoreFullException
Atributos

Ejemplos

En el ejemplo de código siguiente se muestra cómo un error de programación en un subproceso puede conducir a un SemaphoreFullException en otro subproceso: dos subprocesos entran en un semáforo.The following code example shows how a programming error in one thread can lead to a SemaphoreFullException in another thread: Two threads enter a semaphore. El segundo subproceso libera el semáforo dos veces, mientras que el primer subproceso sigue ejecutando su tarea.The second thread releases the semaphore twice, while the first thread is still executing its task. Cuando el primer subproceso finaliza y libera el semáforo, el recuento de semáforos ya está lleno y se produce una excepción.When the first thread finishes and releases the semaphore, the semaphore count is already full and an exception is thrown.

#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 reduce 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 subsiguientes 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 está en 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. Si un error de programación hace que un subproceso llame al Semaphore.Release método en este punto, SemaphoreFullException se produce una excepción.If a programming error causes a thread to call the Semaphore.Release method at this point, a SemaphoreFullException is thrown.

Nota

La Semaphore clase no exige la identidad del subproceso en las llamadas a los WaitHandle.WaitOne Semaphore.Release métodos y.The Semaphore class does not enforce thread identity on calls to the WaitHandle.WaitOne and Semaphore.Release methods. No es necesario para el mismo subproceso al que llamó WaitOne para llamar a Release .It is not necessary for the same thread that called WaitOne to call Release.

SemaphoreFullException no indica necesariamente un problema con el código donde se produjo la excepción.SemaphoreFullException does not necessarily indicate a problem with the code where the exception occurred. Considere el siguiente escenario: el subproceso A y el subproceso B entran en un semáforo con un recuento máximo de dos.Consider the following scenario: Thread A and thread B enter a semaphore that has a maximum count of two. Un error de programación en el subproceso B hace que llame a Release dos veces, de modo que el recuento en el semáforo esté lleno.A programming error in thread B causes it to call Release twice, so that the count on the semaphore is full. Como resultado, cuando el subproceso a finalmente llama a Release , SemaphoreFullException se produce una excepción.As a result, when thread A eventually calls Release, a SemaphoreFullException is thrown.

Para obtener una lista con los valores de propiedad iniciales de una instancia de la clase SemaphoreFullException, vea el constructor SemaphoreFullException().For a list of initial property values for an instance of the SemaphoreFullException class, see the SemaphoreFullException() constructor.

Constructores

SemaphoreFullException()

Inicializa una nueva instancia de la clase SemaphoreFullException con valores predeterminados.Initializes a new instance of the SemaphoreFullException class with default values.

SemaphoreFullException(SerializationInfo, StreamingContext)

Inicializa una nueva instancia de la clase SemaphoreFullException con datos serializados.Initializes a new instance of the SemaphoreFullException class with serialized data.

SemaphoreFullException(String)

Inicializa una nueva instancia de la clase SemaphoreFullException con el mensaje de error especificado.Initializes a new instance of the SemaphoreFullException class with a specified error message.

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.Initializes a new instance of the SemaphoreFullException class with a specified error message and a reference to the inner exception that is the cause of this exception.

Propiedades

Data

Obtiene una colección de pares clave/valor que proporciona información definida por el usuario adicional sobre la excepción.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Heredado de Exception)
HelpLink

Obtiene o establece un vínculo al archivo de ayuda asociado a esta excepción.Gets or sets a link to the help file associated with this exception.

(Heredado de Exception)
HResult

Obtiene o establece HRESULT, un valor numérico codificado que se asigna a una excepción específica.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Heredado de Exception)
InnerException

Obtiene la instancia Exception que produjo la excepción actual.Gets the Exception instance that caused the current exception.

(Heredado de Exception)
Message

Obtiene un mensaje que describe la excepción actual.Gets a message that describes the current exception.

(Heredado de Exception)
Source

Devuelve o establece el nombre de la aplicación o del objeto que generó el error.Gets or sets the name of the application or the object that causes the error.

(Heredado de Exception)
StackTrace

Obtiene una representación de cadena de los marcos inmediatos en la pila de llamadas.Gets a string representation of the immediate frames on the call stack.

(Heredado de Exception)
TargetSite

Obtiene el método que produjo la excepción actual.Gets the method that throws the current exception.

(Heredado de Exception)

Métodos

Equals(Object)

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

(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.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Heredado de Exception)
GetHashCode()

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

(Heredado de Object)
GetObjectData(SerializationInfo, StreamingContext)

Cuando se invalida en una clase derivada, establece SerializationInfo con información sobre la excepción.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Heredado de Exception)
GetType()

Obtiene el tipo de tiempo de ejecución de la instancia actual.Gets the runtime type of the current instance.

(Heredado de Exception)
MemberwiseClone()

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

(Heredado de Object)
ToString()

Crea y devuelve una representación de cadena de la excepción actual.Creates and returns a string representation of the current exception.

(Heredado de Exception)

Eventos

SerializeObjectState

Ocurre cuando una excepción se serializa para crear un objeto de estado de excepción que contenga datos serializados sobre la excepción.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Heredado de Exception)

Se aplica a

Consulte también