Semaphore 클래스

정의

리소스 또는 리소스 풀에 동시에 액세스할 수 있는 스레드 수를 제한합니다.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
상속
특성

예제

다음 코드 예제에서는 세 개의 최대 개수를 및 0에 대 한 초기 카운트를 사용 하 여 세마포를 만듭니다.The following code example creates a semaphore with a maximum count of three and an initial count of zero. 이 예제에서는 세마포를 기다리는 동안 차단 하는 5 개의 스레드를 시작 합니다.The example starts five threads, which block waiting for the semaphore. 주 스레드에서 Release(Int32) 세마포를 입력 하려면 3 개의 스레드를 허용 합니다. 최대값으로 세마포 수를 늘리려면 메서드 오버 로드 합니다.The main thread uses the Release(Int32) method overload to increase the semaphore count to its maximum, allowing three threads to enter the semaphore. 각 스레드가 사용 하는 Thread.Sleep 1 초 동안 기다린 후 작업을 시뮬레이션 한 다음 호출 하는 방법의 Release() 세마포를 해제 메서드 오버 로드 합니다.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. 세마포를 해제 될 때마다 이전 세마포 카운트가 표시 됩니다.Each time the semaphore is released, the previous semaphore count is displayed. 콘솔 메시지 세마포 사용을 추적 합니다.Console messages track semaphore use. 시뮬레이션 된 작업 간격 출력을 쉽게 읽을 수 있도록 각 스레드에 대해 약간 증가 합니다.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.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

설명

사용 된 Semaphore 리소스 풀에 대 한 액세스를 제어 하는 클래스입니다.Use the Semaphore class to control access to a pool of resources. 스레드가 세마포를 호출 하 여는 WaitOne 에서 상속 된 메서드를 WaitHandle 클래스를 호출 하 여 세마포를 해제 합니다 Release 메서드.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.

도달한 세마포에 대해 개수가 스레드가 세마포를 입력 하 고는 스레드가 세마포를 해제할 때 증가 될 때마다 감소 됩니다.The count on a semaphore is decremented each time a thread enters the semaphore, and incremented when a thread releases the semaphore. 횟수가 0 일 경우 후속 요청에 다른 스레드가 세마포를 해제할 때까지 차단 합니다.When the count is zero, subsequent requests block until other threads release the semaphore. 모든 스레드가 세마포를 해제 한 경우 개수는 최 댓 값에 만들어질 때 지정 된 세마포 합니다.When all threads have released the semaphore, the count is at the maximum value specified when the semaphore was created.

FIFO 등 LIFO, 차단 된 스레드가 세마포를 입력할 수 있는 보장 된 순서 없이 있습니다.There is no guaranteed order, such as FIFO or LIFO, in which blocked threads enter the semaphore.

스레드가 세마포에 들어갈 수를 여러 번 호출 하 여는 WaitOne 메서드 반복적으로 합니다.A thread can enter the semaphore multiple times, by calling the WaitOne method repeatedly. 이러한 항목 중 일부나 전부를 해제 하려면 스레드 매개 변수가 없는 호출 수 Release() 메서드 오버 로드를 여러 번 하거나 호출할 수는 Release(Int32) 해제할 항목 수를 지정 하는 메서드 오버 로드 합니다.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.

합니다 Semaphore 클래스에 대 한 호출에서 스레드 id를 적용 하지 않습니다 WaitOne 또는 Release합니다.The Semaphore class does not enforce thread identity on calls to WaitOne or Release. 프로그래머는 스레드는 해제 하지 않아 세마포를 너무 여러 번 확인 하는 것입니다.It is the programmer's responsibility to ensure that threads do not release the semaphore too many times. 예를 들어 세마포의 최대 개수가 2개인데 스레드 A와 스레드 B가 모두 세마포를 입력한다고 가정해 보겠습니다.For example, suppose a semaphore has a maximum count of two, and that thread A and thread B both enter the semaphore. 스레드 B에서에서 프로그래밍 오류를 호출 하면 Release 을 두 번 두 호출은 모두 성공 합니다.If a programming error in thread B causes it to call Release twice, both calls succeed. 그러면 세마포 개수가 다 차서 스레드 A가 Release를 호출하면 SemaphoreFullException이 throw됩니다.The count on the semaphore is full, and when thread A eventually calls Release, a SemaphoreFullException is thrown.

세마포는 두 가지 유형입니다: 로컬 세마포 및 명명 된 시스템 세마포 합니다.Semaphores are of two types: local semaphores and named system semaphores. 만드는 경우는 Semaphore 이름을 허용 하는 생성자를 사용 하 여 해당 이름의 운영 체제 세마포를 사용 하 여 연결 됩니다.If you create a Semaphore object using a constructor that accepts a name, it is associated with an operating-system semaphore of that name. 명명 된 시스템 세마포 전체 운영 체제에 표시 되 고 사용 하 여 프로세스 작업을 동기화 할 수 있습니다.Named system semaphores are visible throughout the operating system, and can be used to synchronize the activities of processes. 여러 개 만들 수 있습니다 Semaphore 동일한 나타내는 개체를 명명 된 시스템 세마포를 및 사용할 수는 OpenExisting 명명 된 시스템 세마포가 기존 방법입니다.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.

로컬 세마포가 프로세스 내에 존재합니다.A local semaphore exists only within your process. 로컬 Semaphore 개체에 대한 참조가 있는 프로세스의 모든 스레드에서 사용할 수 있습니다.It can be used by any thread in your process that has a reference to the local Semaphore object. Semaphore 개체는 별도 로컬 세마포입니다.Each Semaphore object is a separate local semaphore.

생성자

Semaphore(Int32, Int32)

초기 항목 수와 최대 동시 항목 수를 지정하여 Semaphore 클래스의 새 인스턴스를 초기화합니다.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 클래스의 새 인스턴스를 초기화합니다.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 클래스의 새 인스턴스를 초기화합니다.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 클래스의 새 인스턴스를 초기화합니다.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.

필드

WaitTimeout

대기 핸들이 신호를 받기 전에 WaitAny(WaitHandle[], Int32, Boolean) 작업이 제한 시간을 초과했음을 나타냅니다.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. 이 필드는 상수입니다.This field is constant.

(다음에서 상속됨 WaitHandle)

속성

Handle

네이티브 운영 체제 핸들을 가져오거나 설정합니다.Gets or sets the native operating system handle.

(다음에서 상속됨 WaitHandle)
SafeWaitHandle

네이티브 운영 체제 핸들을 가져오거나 설정합니다.Gets or sets the native operating system handle.

(다음에서 상속됨 WaitHandle)

메서드

Close()

현재 WaitHandle에서 보유한 모든 리소스를 해제합니다.Releases all resources held by the current WaitHandle.

(다음에서 상속됨 WaitHandle)
CreateObjRef(Type)

원격 개체와 통신하는 데 사용되는 프록시 생성에 필요한 모든 관련 정보가 들어 있는 개체를 만듭니다.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(다음에서 상속됨 MarshalByRefObject)
Dispose()

WaitHandle 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the current instance of the WaitHandle class.

(다음에서 상속됨 WaitHandle)
Dispose(Boolean)

파생 클래스에서 재정의된 경우 WaitHandle에서 사용하는 관리되지 않는 리소스를 해제하고 필요에 따라 관리되는 리소스를 해제합니다.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(다음에서 상속됨 WaitHandle)
Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
GetAccessControl()

명명된 시스템 세마포에 대한 액세스 제어 보안을 가져옵니다.Gets the access control security for a named system semaphore.

GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetLifetimeService()

이 인스턴스의 수명 정책을 제어하는 현재의 수명 서비스 개체를 검색합니다.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(다음에서 상속됨 MarshalByRefObject)
GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
InitializeLifetimeService()

이 인스턴스의 수명 정책을 제어하는 수명 서비스 개체를 가져옵니다.Obtains a lifetime service object to control the lifetime policy for this instance.

(다음에서 상속됨 MarshalByRefObject)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
MemberwiseClone(Boolean)

현재 MarshalByRefObject 개체의 단순 복사본을 만듭니다.Creates a shallow copy of the current MarshalByRefObject object.

(다음에서 상속됨 MarshalByRefObject)
OpenExisting(String)

이미 있는 경우 지정한 명명된 세마포를 엽니다.Opens the specified named semaphore, if it already exists.

OpenExisting(String, SemaphoreRights)

이미 있는 경우 지정한 명명된 세마포를 원하는 보안 액세스로 엽니다.Opens the specified named semaphore, if it already exists, with the desired security access.

Release()

세마포를 종료하고 이전 카운트를 반환합니다.Exits the semaphore and returns the previous count.

Release(Int32)

지정된 횟수만큼 세마포를 종료하고 이전 카운트를 반환합니다.Exits the semaphore a specified number of times and returns the previous count.

SetAccessControl(SemaphoreSecurity)

명명된 시스템 세마포에 대한 액세스 제어 보안을 설정합니다.Sets the access control security for a named system semaphore.

ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)
TryOpenExisting(String, Semaphore)

지정한 명명된 세마포(이미 존재하는 경우)를 열고 작업이 성공했는지를 나타내는 값을 반환합니다.Opens the specified named semaphore, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, SemaphoreRights, Semaphore)

지정한 명명된 세마포(이미 존재하는 경우)를 원하는 보안 액세스로 열고 작업이 성공적으로 수행되었는지 여부를 나타내는 값을 반환합니다.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()

현재 WaitHandle이(가) 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current WaitHandle receives a signal.

(다음에서 상속됨 WaitHandle)
WaitOne(Int32)

부호 있는 32비트 정수로 시간 간격(밀리초)을 지정하여 현재 WaitHandle이 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(다음에서 상속됨 WaitHandle)
WaitOne(Int32, Boolean)

부호 있는 32비트 정수로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 현재 WaitHandle이 신호를 받을 때까지 현재 스레드를 차단합니다.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.

(다음에서 상속됨 WaitHandle)
WaitOne(TimeSpan)

TimeSpan로 시간 간격을 지정하여 현재 인스턴스가 신호를 받을 때까지 현재 스레드를 차단합니다.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(다음에서 상속됨 WaitHandle)
WaitOne(TimeSpan, Boolean)

TimeSpan로 시간 간격을 지정하고 대기 전에 동기화 도메인을 끝낼지 여부를 지정하여 현재 인스턴스가 신호를 받을 때까지 현재 스레드를 차단합니다.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.

(다음에서 상속됨 WaitHandle)

명시적 인터페이스 구현

IDisposable.Dispose()

WaitHandle에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the WaitHandle.

(다음에서 상속됨 WaitHandle)

확장 메서드

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

네이티브 운영 체제 대기 핸들에 대한 안전한 핸들을 가져옵니다.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

네이티브 운영 체제 대기 핸들에 대한 안전한 핸들을 설정합니다.Sets a safe handle for a native operating system wait handle.

적용 대상

스레드 보안

이 형식은 스레드로부터 안전합니다.This type is thread safe.

추가 정보