Semaphore Semaphore Semaphore Semaphore Class

定義

リソースまたはリソースのプールに同時にアクセスできるスレッドの数を制限します。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 の最初の数の 3 つの最大数、およびセマフォを作成します。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
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 でのプログラミング エラー原因を呼び出せるかどうかRelease2 回、両方の呼び出しが成功します。If a programming error in thread B causes it to call Release twice, both calls succeed. セマフォのカウントがいっぱいになっているときに、スレッド A も Release を呼び出すと、SemaphoreFullException がスローされます。The count on the semaphore is full, and when thread A eventually calls Release, a SemaphoreFullException is thrown.

セマフォは次の 2 つの種類: ローカル セマフォおよび名前付きシステム セマフォです。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(Int32, Int32) Semaphore(Int32, Int32) 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(Int32, Int32, String) Semaphore(Int32, Int32, String) 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(Int32, Int32, String, Boolean) Semaphore(Int32, Int32, String, Boolean) 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(Int32, Int32, String, Boolean, SemaphoreSecurity) Semaphore(Int32, Int32, String, Boolean, SemaphoreSecurity) 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.

メソッド

Close() Close() Close() Close()

現在の WaitHandle によって保持されているすべてのリソースを解放します。Releases all resources held by the current WaitHandle.

(Inherited from WaitHandle)
CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

リモート オブジェクトとの通信に使用するプロキシの生成に必要な情報をすべて格納しているオブジェクトを作成します。Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

WaitHandle クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。Releases all resources used by the current instance of the WaitHandle class.

(Inherited from WaitHandle)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

派生クラスでオーバーライドされると、WaitHandle によって使用されているアンマネージド リソースを解放し、オプションでマネージド リソースも解放します。When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Inherited from WaitHandle)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

指定したオブジェクトが、現在のオブジェクトと等しいかどうかを判断します。Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetAccessControl() GetAccessControl() GetAccessControl() GetAccessControl()

名前付きシステム セマフォのアクセス制御セキュリティを取得します。Gets the access control security for a named system semaphore.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

既定のハッシュ関数として機能します。Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

対象のインスタンスの有効期間ポリシーを制御する、現在の有効期間サービス オブジェクトを取得します。Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

現在のインスタンスの Type を取得します。Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

このインスタンスの有効期間ポリシーを制御する有効期間サービス オブジェクトを取得します。Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

現在の Object の簡易コピーを作成します。Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

現在の MarshalByRefObject オブジェクトの簡易コピーを作成します。Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
OpenExisting(String) OpenExisting(String) OpenExisting(String) OpenExisting(String)

既に存在する場合は、指定した名前付きセマフォを開きます。Opens the specified named semaphore, if it already exists.

OpenExisting(String, SemaphoreRights) OpenExisting(String, SemaphoreRights) OpenExisting(String, SemaphoreRights) OpenExisting(String, SemaphoreRights)

既に存在する場合は、必要なセキュリティ アクセスで指定した名前付きセマフォを開きます。Opens the specified named semaphore, if it already exists, with the desired security access.

Release() Release() Release() Release()

セマフォから出て、前のカウントを返します。Exits the semaphore and returns the previous count.

Release(Int32) Release(Int32) Release(Int32) Release(Int32)

指定した回数だけセマフォから出て、前のカウントを返します。Exits the semaphore a specified number of times and returns the previous count.

SetAccessControl(SemaphoreSecurity) SetAccessControl(SemaphoreSecurity) SetAccessControl(SemaphoreSecurity) SetAccessControl(SemaphoreSecurity)

名前付きシステム セマフォのアクセス制御セキュリティを設定します。Sets the access control security for a named system semaphore.

ToString() ToString() ToString() ToString()

現在のオブジェクトを表す文字列を返します。Returns a string that represents the current object.

(Inherited from Object)
TryOpenExisting(String, Semaphore) TryOpenExisting(String, Semaphore) TryOpenExisting(String, Semaphore) 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) TryOpenExisting(String, SemaphoreRights, Semaphore) TryOpenExisting(String, SemaphoreRights, Semaphore) 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() WaitOne() WaitOne() WaitOne()

現在の WaitHandle がシグナルを受け取るまで、現在のスレッドをブロックします。Blocks the current thread until the current WaitHandle receives a signal.

(Inherited from WaitHandle)
WaitOne(Int32) WaitOne(Int32) WaitOne(Int32) 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.

(Inherited from WaitHandle)
WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean)

現在の WaitHandle がシグナルを受信するまで現在のスレッドをブロックします。時間間隔を指定するために 32 ビット符号付き整数を使用し、待機の前でも同期ドメインを終了するかどうかを指定します。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.

(Inherited from WaitHandle)
WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan)

TimeSpan を使用して時間間隔を指定し、現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Inherited from WaitHandle)
WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) 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.

(Inherited from WaitHandle)

プロパティ

Handle Handle Handle Handle

ネイティブ オペレーティング システム ハンドルを取得または設定します。Gets or sets the native operating system handle.

(Inherited from WaitHandle)
SafeWaitHandle SafeWaitHandle SafeWaitHandle SafeWaitHandle

ネイティブ オペレーティング システム ハンドルを取得または設定します。Gets or sets the native operating system handle.

(Inherited from WaitHandle)

明示的なインターフェイスの実装

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

WaitHandle によって使用されているすべてのリソースを解放します。Releases all resources used by the WaitHandle.

(Inherited from WaitHandle)

フィールド

WaitTimeout WaitTimeout WaitTimeout 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.

(Inherited from WaitHandle)

拡張メソッド

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

ネイティブ オペレーティング システムの待機ハンドルのためのセーフ ハンドルを取得します。Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

ネイティブ オペレーティング システムの待機ハンドルのためのセーフ ハンドルを設定します。Sets a safe handle for a native operating system wait handle.

適用対象

スレッド セーフ

この型はスレッド セーフです。This type is thread safe.

こちらもご覧ください