이 설명서는 보관되지만 유지 되지 않습니다.

SemaphoreFullException 클래스

참고: 이 클래스는 .NET Framework 버전 2.0에서 새로 추가되었습니다.

카운트가 이미 최대값에 도달한 세마포에서 System.Threading.Semaphore.Release 메서드를 호출하면 throw되는 예외입니다.

네임스페이스: System.Threading
어셈블리: System(system.dll)

[SerializableAttribute] 
[ComVisibleAttribute(false)] 
public class SemaphoreFullException : SystemException
/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(false) */ 
public class SemaphoreFullException extends SystemException
SerializableAttribute 
ComVisibleAttribute(false) 
public class SemaphoreFullException extends SystemException

세마포에 대한 카운트는 스레드가 세마포에 진입할 때마다 감소하고 스레드가 세마포를 해제하면 증가합니다. 카운트가 0이면 다른 스레드가 세마포를 해제할 때까지 후속 요청이 차단됩니다. 모든 스레드가 세마포를 해제하면 카운트는 세마포가 만들어질 때 지정된 최대값이 됩니다. 이 시점에서 프로그래밍 오류로 인해 스레드가 System.Threading.Semaphore.Release 메서드를 호출하면 SemaphoreFullException이 throw됩니다.

Note참고

Semaphore 클래스는 System.Threading.WaitHandle.WaitOneSystem.Threading.Semaphore.Release 메서드를 호출할 때 스레드 ID를 적용하지 않습니다. WaitOne을 호출한 스레드와 Release를 호출할 스레드가 같을 필요는 없습니다.

SemaphoreFullException이 표시된다고 해서 예외가 발생한 코드에 반드시 문제가 있는 것은 아닙니다. 스레드 A와 B가 최대 카운트가 2인 세마포에 진입하는 시나리오가 있다고 가정해 보겠습니다. 스레드 B의 프로그래밍 오류로 인해 스레드가 Release를 두 번 호출하여 세마포 카운트가 최대값에 도달했습니다. 결과적으로 스레드 A가 Release를 호출하면 SemaphoreFullException이 throw됩니다.

SemaphoreFullException 클래스의 인스턴스에 대한 초기 속성 값 목록을 보려면 SemaphoreFullException 생성자를 참조하십시오.

다음 코드 예제에서는 한 스레드에 프로그래밍 오류가 있을 때 어떻게 다른 스레드에 SemaphoreFullException이 발생(두 스레드가 세마포에 진입)하게 되는지 보여 줍니다. 첫 번째 스레드에서 아직 작업을 실행하고 있는데 두 번째 스레드가 세마포를 두 번 해제합니다. 첫 번째 스레드가 작업을 종료하고 세마포를 해제해도 세마포 카운트가 이미 최대값에 도달하여 예외가 throw됩니다.

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.
 */

import System.*;
import 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(String[] args)
    {
        // Create and start two threads, A and B. 
        //
        System.Threading.Thread tA = new System.Threading.Thread(new 
            ThreadStart(ThreadA));
        tA.Start();

        System.Threading.Thread tB = new System.Threading.Thread(new 
            ThreadStart(ThreadB));
        tB.Start();
    } //main

    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.");
        System.Threading.Thread.Sleep(1000);

        try {
            pool.Release();
            Console.WriteLine("Thread A released the semaphore.");
        }
        catch (System.Exception ex) {
            Console.WriteLine("Thread A: {0}", ex.get_Message());
        }
    } //ThreadA

    private static void ThreadB()
    {
        // Thread B simulates a task that lasts half a second,
        // then enters the semaphore.
        //
        System.Threading.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.");
    } //ThreadB
} //Example
/* 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.
 */

System.Object
   System.Exception
     System.SystemException
      System.Threading.SemaphoreFullException

이 형식의 모든 public static(Visual Basic의 경우 Shared) 멤버는 스레드로부터 안전합니다. 인터페이스 멤버는 스레드로부터 안전하지 않습니다.

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework에서 모든 플래폼의 모든 버전을 지원하지는 않습니다. 지원되는 버전의 목록은 시스템 요구 사항을 참조하십시오.

.NET Framework

2.0에서 지원
표시: