SemaphoreFullException Classe

Definição

Namespace:

System.Threading

Assembly:

System.Threading.dll

Assembly:

System.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

A exceção que é lançada quando o método Release é chamado em um semáforo cuja contagem já está no 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

Herança

Object

Exception

SemaphoreFullException

Herança

Object

Exception

SystemException

SemaphoreFullException

Atributos

ComVisibleAttribute SerializableAttribute

Exemplos

O exemplo de código a seguir mostra como um erro de programação em um thread pode levar a um SemaphoreFullException em outro thread: dois threads entram em um semáforo. O segundo thread libera o semáforo duas vezes, enquanto o primeiro thread ainda está executando sua tarefa. Quando o primeiro thread é concluído e libera o semáforo, a contagem de semáforos já está cheia e uma exceção é gerada.

#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.
'

Comentários

A contagem em um semáforo é decrementada sempre que um thread entra no semáforo e incrementado quando um thread libera o semáforo. Quando a contagem for zero, as solicitações subsequentes serão bloqueadas até que outros threads liberem o semáforo. Quando todos os threads liberam o semáforo, a contagem está no valor máximo especificado quando o semáforo foi criado. Se um erro de programação fizer com que um thread chame o Semaphore.Release método neste ponto, um SemaphoreFullException será gerado.

Observação

A Semaphore classe não impõe a identidade do thread em chamadas para os WaitHandle.WaitOne métodos e Semaphore.Release . Não é necessário para o mesmo thread que chamou WaitOne para chamar Release.

SemaphoreFullException não indica necessariamente um problema com o código em que a exceção ocorreu. Considere o cenário a seguir: Thread A e thread B insira um semáforo que tenha uma contagem máxima de dois. Um erro de programação no thread B faz com que ele chame Release duas vezes, para que a contagem no semáforo esteja cheia. Como resultado, quando o thread A eventualmente chama Release, um SemaphoreFullException é gerado.

Para obter uma lista de valores de propriedade iniciais para uma instância da SemaphoreFullException classe , consulte o SemaphoreFullException() construtor .

Construtores

SemaphoreFullException()	Inicializa uma nova instância da classe SemaphoreFullException com valores padrão.
SemaphoreFullException(SerializationInfo, StreamingContext)	Inicializa uma nova instância da classe SemaphoreFullException com dados serializados.
SemaphoreFullException(String)	Inicializa uma nova instância da classe SemaphoreFullException com uma mensagem de erro especificada.
SemaphoreFullException(String, Exception)	Inicializa uma nova instância da classe SemaphoreFullException com uma mensagem de erro especificada e uma referência à exceção interna que é a causa da exceção.

Propriedades

Data	Obtém uma coleção de pares de chave/valor que fornecem informações definidas pelo usuário adicionais sobre a exceção. (Herdado de Exception)
HelpLink	Obtém ou define um link para o arquivo de ajuda associado a essa exceção. (Herdado de Exception)
HResult	Obtém ou define HRESULT, um valor numérico codificado que é atribuído a uma exceção específica. (Herdado de Exception)
InnerException	Obtém a instância Exception que causou a exceção atual. (Herdado de Exception)
Message	Obtém uma mensagem que descreve a exceção atual. (Herdado de Exception)
Source	Obtém ou define o nome do aplicativo ou objeto que causa o erro. (Herdado de Exception)
StackTrace	Obtém uma representação de cadeia de caracteres de quadros imediatos na pilha de chamadas. (Herdado de Exception)
TargetSite	Obtém o método que gerou a exceção atual. (Herdado de Exception)

Métodos

Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetBaseException()	Quando substituído em uma classe derivada, retorna a Exception que é a causa raiz de uma ou mais exceções subsequentes. (Herdado de Exception)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetObjectData(SerializationInfo, StreamingContext)	Quando substituído em uma classe derivada, define o SerializationInfo com informações sobre a exceção. (Herdado de Exception)
GetType()	Obtém o tipo de runtime da instância atual. (Herdado de Exception)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
ToString()	Cria e retorna uma representação de cadeia de caracteres da exceção atual. (Herdado de Exception)

Eventos

SerializeObjectState

Obsoleto. Ocorre quando uma exceção é serializada para criar um objeto de estado de exceção que contém dados serializados sobre a exceção. (Herdado de Exception)

Confira também

• Semaphore
• Sinal