Mutex クラス

定義

同期プリミティブは、プロセス間の同期にも使用できます。A synchronization primitive that can also be used for interprocess synchronization.

public ref class Mutex sealed : System::Threading::WaitHandle
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Mutex : System.Threading.WaitHandle
type Mutex = class
    inherit WaitHandle
Public NotInheritable Class Mutex
Inherits WaitHandle
継承
属性

この例では、ローカルMutexオブジェクトを使用して、保護されたリソースへのアクセスを同期する方法を示します。This example shows how a local Mutex object is used to synchronize access to a protected resource. ミューテックスの所有権を取得するまで、呼び出し元のスレッドはブロックされるためReleaseMutex 、スレッドの所有権を解放するにはメソッドを呼び出す必要があります。Because each calling thread is blocked until it acquires ownership of the mutex, it must call the ReleaseMutex method to release ownership of the thread.

using System;
using System.Threading;

class Example
{
    // Create a new Mutex. The creating thread does not own the mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name);
        mut.WaitOne();

        Console.WriteLine("{0} has entered the protected area", 
                          Thread.CurrentThread.Name);

        // Place code to access non-reentrant resources here.

        // Simulate some work.
        Thread.Sleep(500);

        Console.WriteLine("{0} is leaving the protected area", 
            Thread.CurrentThread.Name);

        // Release the Mutex.
        mut.ReleaseMutex();
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name);
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread2 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread3 is requesting the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
//       Thread3 has released the mutex
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       Thread2 has released the mutex
Imports System.Threading

Module Example
   ' Create a new Mutex. The creating thread does not own the mutex.
   Private mut As New Mutex()
   Private Const numIterations As Integer = 1
   Private Const numThreads As Integer = 3
   
   Public Sub Main()
        ' Create the threads that will use the protected resource.
        For i As Integer = 0 To numThreads - 1
            Dim newThread As New Thread(AddressOf ThreadProc)
            newThread.Name = String.Format("Thread{0}", i + 1)
            newThread.Start()
        Next

        ' The main thread exits, but the application continues to
        ' run until all foreground threads have exited.
    End Sub

    Private Sub ThreadProc()
        For i As Integer = 0 To numIterations - 1
            UseResource()
        Next
    End Sub

    ' This method represents a resource that must be synchronized
    ' so that only one thread at a time can enter.
    Private Sub UseResource()
        ' Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name)
        mut.WaitOne()

        Console.WriteLine("{0} has entered the protected area", 
                          Thread.CurrentThread.Name)

        ' Place code to access non-reentrant resources here.

        ' Simulate some work.
        Thread.Sleep(500)

        Console.WriteLine("{0} is leaving the protected area", 
            Thread.CurrentThread.Name)

        ' Release the Mutex.
        mut.ReleaseMutex()
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name)
   End Sub
End Module
' The example displays output like the following:
'       Thread1 is requesting the mutex
'       Thread2 is requesting the mutex
'       Thread1 has entered the protected area
'       Thread3 is requesting the mutex
'       Thread1 is leaving the protected area
'       Thread1 has released the mutex
'       Thread3 has entered the protected area
'       Thread3 is leaving the protected area
'       Thread3 has released the mutex
'       Thread2 has entered the protected area
'       Thread2 is leaving the protected area
'       Thread2 has released the mutex

次の例では、各スレッドがWaitOne(Int32)メソッドを呼び出して、ミューテックスを取得します。In the following example, each thread calls the WaitOne(Int32) method to acquire the mutex. タイムアウト間隔が経過すると、メソッドはを返しfalse、スレッドはミューテックスを取得せず、ミューテックスによって保護されるリソースへのアクセスも取得しません。If the time-out interval elapses, the method returns false, and the thread neither acquires the mutex nor gains access to the resource the mutex protects. ReleaseMutexメソッドは、ミューテックスを取得するスレッドによってのみ呼び出されます。The ReleaseMutex method is called only by the thread that acquires the mutex.

using System;
using System.Threading;

class Example
{
    // Create a new Mutex. The creating thread does not own the mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        Example ex = new Example();
        ex.StartThreads();
    }

     private void StartThreads()
     {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread returns to Main and exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter, and do not enter if the request times out.
        Console.WriteLine("{0} is requesting the mutex", Thread.CurrentThread.Name);
        if (mut.WaitOne(1000)) {
           Console.WriteLine("{0} has entered the protected area", 
               Thread.CurrentThread.Name);
   
           // Place code to access non-reentrant resources here.
   
           // Simulate some work.
           Thread.Sleep(5000);
   
           Console.WriteLine("{0} is leaving the protected area", 
               Thread.CurrentThread.Name);
   
           // Release the Mutex.
              mut.ReleaseMutex();
           Console.WriteLine("{0} has released the mutex", 
                             Thread.CurrentThread.Name);
        }
        else {
           Console.WriteLine("{0} will not acquire the mutex", 
                             Thread.CurrentThread.Name);
        }
    }

    ~Example()
    {
       mut.Dispose();
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread2 is requesting the mutex
//       Thread3 is requesting the mutex
//       Thread2 will not acquire the mutex
//       Thread3 will not acquire the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex
Imports System.Threading

Class Example
   ' Create a new Mutex. The creating thread does not own the mutex.
   Private mut As New Mutex()
   Private Const numIterations As Integer = 1
   Private Const numThreads As Integer = 3

   Public Shared Sub Main()
      Dim ex As New Example()
      ex.StartThreads()
   End Sub
   
   Private Sub StartThreads()
        ' Create the threads that will use the protected resource.
        For i As Integer = 0 To numThreads - 1
            Dim newThread As New Thread(AddressOf ThreadProc)
            newThread.Name = String.Format("Thread{0}", i + 1)
            newThread.Start()
        Next

        ' The main thread returns to Main and exits, but the application continues to
        ' run until all foreground threads have exited.
   End Sub

   Private Sub ThreadProc()
        For i As Integer = 0 To numIterations - 1
            UseResource()
        Next
   End Sub

   ' This method represents a resource that must be synchronized
   ' so that only one thread at a time can enter.
   Private Sub UseResource()
        ' Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name)
        If mut.WaitOne(1000) Then
           Console.WriteLine("{0} has entered the protected area", 
               Thread.CurrentThread.Name)
   
           ' Place code to access non-reentrant resources here.
   
           ' Simulate some work.
           Thread.Sleep(5000)
   
           Console.WriteLine("{0} is leaving the protected area", 
               Thread.CurrentThread.Name)
   
           ' Release the Mutex.
           mut.ReleaseMutex()
           Console.WriteLine("{0} has released the mutex", 
                             Thread.CurrentThread.Name)
        Else
           Console.WriteLine("{0} will not acquire the mutex", 
                             Thread.CurrentThread.Name)
        End If
   End Sub
   
   Protected Overrides Sub Finalize()
      mut.Dispose()
   End Sub
End Class
' The example displays output like the following:
'       Thread1 is requesting the mutex
'       Thread1 has entered the protected area
'       Thread2 is requesting the mutex
'       Thread3 is requesting the mutex
'       Thread2 will not acquire the mutex
'       Thread3 will not acquire the mutex
'       Thread1 is leaving the protected area
'       Thread1 has released the mutex

注釈

2つ以上のスレッドが共有リソースに同時にアクセスする必要がある場合、システムには、一度に1つのスレッドのみがリソースを使用するように同期機構が必要です。When two or more threads need to access a shared resource at the same time, the system needs a synchronization mechanism to ensure that only one thread at a time uses the resource. Mutexは、共有リソースへの排他アクセスを1つのスレッドにのみ許可する同期プリミティブです。Mutex is a synchronization primitive that grants exclusive access to the shared resource to only one thread. スレッドがミューテックスを取得した場合、そのミューテックスを取得する2番目のスレッドは、最初のスレッドがミューテックスを解放するまで中断されます。If a thread acquires a mutex, the second thread that wants to acquire that mutex is suspended until the first thread releases the mutex.

重要

この型は IDisposable インターフェイスを実装します。This type implements the IDisposable interface. 型の使用が完了したら、直接的または間接的に型を破棄する必要があります。When you have finished using the type, you should dispose of it either directly or indirectly. 直接的に型を破棄するには、try / catch ブロック内で Dispose メソッドを呼び出します。To dispose of the type directly, call its Dispose method in a try/catch block. 間接的に型を破棄するには、using (C# の場合) または Using (Visual Basic 言語) などの言語構成要素を使用します。To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). 詳細については、IDisposable インターフェイスに関するトピック内の「IDisposable を実装するオブジェクトの使用」セクションを参照してください。For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

メソッドを使用しWaitHandle.WaitOneて、ミューテックスの所有権を要求できます。You can use the WaitHandle.WaitOne method to request ownership of a mutex. 呼び出し元のスレッドは、次のいずれかが発生するまでブロックします。The calling thread blocks until one of the following occurs:

  • ミューテックスは、所有されていないことを示すシグナルとして通知されます。The mutex is signaled to indicate that it is not owned. この場合、メソッドはWaitOneを返しtrue、呼び出し元のスレッドはミューテックスの所有権を前提とし、ミューテックスによって保護されているリソースにアクセスします。When this happens, the WaitOne method returns true, and the calling thread assumes ownership of the mutex and accesses the resource protected by the mutex. リソースへのアクセスが終了したら、スレッドはReleaseMutexメソッドを呼び出して、ミューテックスの所有権を解放する必要があります。When it has finished accessing the resource, the thread must call the ReleaseMutex method to release ownership of the mutex. 例のセクションの最初の例は、このパターンを示しています。The first example in the Examples section illustrates this pattern.

  • またはWaitOne millisecondsTimeoutパラメーターを持つメソッドの呼び出しで指定されたタイムアウト期間が経過しました。 timeoutThe time-out interval specified in the call to a WaitOne method that has a millisecondsTimeout or timeout parameter has elapsed. この場合、メソッドはWaitOneを返しfalse、呼び出し元のスレッドはミューテックスの所有権を取得しません。When this happens, the WaitOne method returns false, and the calling thread makes no further attempt to acquire ownership of the mutex. この場合は、ミューテックスによって保護されているリソースへのアクセスが呼び出し元のスレッドに対して拒否されるように、コードを構築する必要があります。In this case, you should structure your code so that access to the resource that is protected by the mutex is denied to the calling thread. スレッドがミューテックスの所有権を取得したことはないため、 ReleaseMutexメソッドを呼び出すことはできません。Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. 例のセクションの2番目の例は、このパターンを示しています。The second example in the Examples section illustrates this pattern.

クラスMutexはスレッド id を適用するため、ミューテックスは、それを取得したスレッドによってのみ解放されます。The Mutex class enforces thread identity, so a mutex can be released only by the thread that acquired it. これに対してSemaphore 、クラスはスレッド id を適用しません。By contrast, the Semaphore class does not enforce thread identity. ミューテックスは、アプリケーションドメインの境界を越えて渡すこともできます。A mutex can also be passed across application domain boundaries.

ミューテックスを所有するスレッドは、の実行をブロックせずに、 WaitOneを繰り返し呼び出して同じミューテックスを要求できます。The thread that owns a mutex can request the same mutex in repeated calls to WaitOne without blocking its execution. ただし、ミューテックスの所有権をReleaseMutex解放するには、スレッドが同じ回数だけメソッドを呼び出す必要があります。However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex.

クラスはMutex WaitHandleから継承するため、静的WaitHandle.WaitAllメソッドとWaitHandle.WaitAnyメソッドを呼び出して、保護されたリソースへのアクセスを同期することもできます。Because the Mutex class inherits from WaitHandle, you can also call the static WaitHandle.WaitAll and WaitHandle.WaitAny methods to synchronize access to a protected resource.

ミューテックスを所有している間にスレッドが終了した場合、ミューテックスは破棄されたと言います。If a thread terminates while owning a mutex, the mutex is said to be abandoned. ミューテックスの状態はシグナル状態に設定され、次の待機スレッドは所有権を取得します。The state of the mutex is set to signaled, and the next waiting thread gets ownership. .NET Framework のバージョン2.0 以降では、破棄AbandonedMutexExceptionされたミューテックスを取得する次のスレッドでがスローされます。Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the abandoned mutex. .NET Framework のバージョン2.0 より前では、例外はスローされませんでした。Before version 2.0 of the .NET Framework, no exception was thrown.

注意事項

多くの場合、放棄されたミューテックスは、コードに重大なエラーを示します。An abandoned mutex often indicates a serious error in the code. ミューテックスを解放せずにスレッドが終了すると、ミューテックスによって保護されているデータ構造が一貫性のある状態にならない可能性があります。When a thread exits without releasing the mutex, the data structures protected by the mutex might not be in a consistent state. 次にミューテックスの所有権を要求するスレッドは、この例外を処理し、データ構造の整合性を検証できる場合は処理を続行できます。The next thread to request ownership of the mutex can handle this exception and proceed, if the integrity of the data structures can be verified.

システム全体でミューテックスが有効な場合にミューテックスが破棄されたときは、アプリケーションが強制終了されたことを示している可能性があります (たとえば、Windows タスク マネージャを使用した終了)。In the case of a system-wide mutex, an abandoned mutex might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager).

ミューテックスは、名前のないローカルミューテックスと名前付きシステムミューテックスの2種類です。Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. ローカル ミューテックスは、現在のプロセス内にのみ存在します。A local mutex exists only within your process. これは、ミューテックスを表すMutexオブジェクトへの参照を持つプロセス内の任意のスレッドで使用できます。It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. 名前Mutexのない各オブジェクトは、個別のローカルミューテックスを表します。Each unnamed Mutex object represents a separate local mutex.

名前付きシステムミューテックスはオペレーティングシステム全体に表示され、プロセスのアクティビティを同期するために使用できます。Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. 名前を受け入れるコンストラクター Mutexを使用して、名前付きシステムミューテックスを表すオブジェクトを作成できます。You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. オペレーティングシステムオブジェクトは、同時に作成することも、 Mutexオブジェクトの作成前に存在させることもできます。The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. 同じ名前付きシステム ミューテックスを表す複数の Mutex オブジェクトを作成できます。また、OpenExisting メソッドを使用して、既存の名前付きシステム ミューテックスを開くことができます。You can create multiple Mutex objects that represent the same named system mutex, and you can use the OpenExisting method to open an existing named system mutex.

注意

ターミナルサービスを実行しているサーバーでは、名前付きシステムミューテックスに2つのレベルの可視性を持たせることができます。On a server that is running Terminal Services, a named system mutex can have two levels of visibility. 名前が "Global\" というプレフィックスで始まる場合は、すべてのターミナルサーバーセッションでミューテックスが表示されます。If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. 名前が "Local\" というプレフィックスで始まる場合、ミューテックスは、そのミューテックスが作成されたターミナルサーバーセッションでのみ表示されます。If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. この場合、サーバー上の他の各ターミナルサーバーセッションには、同じ名前のミューテックスが個別に存在する可能性があります。In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. 名前付きミューテックスを作成するときにプレフィックスを指定しないと、プレフィックス "Local\" が使用されます。If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". ターミナルサーバーセッション内では、名前が異なる2つのミューテックスは別々の mutex であり、両方ともターミナルサーバーセッションのすべてのプロセスで表示されます。Within a terminal server session, two mutexes whose names differ only by their prefixes are separate mutexes, and both are visible to all processes in the terminal server session. つまり、プレフィックス名 "Global\" と "Local\" は、ターミナルサーバーセッションを基準とするミューテックス名のスコープを示します。プロセスに対する相対パスではありません。That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes.

円記号 (\) は、ミューテックス名の予約文字です。The backslash (\) is a reserved character in a mutex name. ターミナル サーバー セッションのミューテックス使用に関する注記に指定されていない限り、ミューテックス名に円記号 (\) を使用しないでください。Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. 使用した場合、ミューテックスの名前が既存のファイルを表すとしても、DirectoryNotFoundException がスローされることがあります。Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.

コンストラクター

Mutex()

Mutex クラスの新しいインスタンスを、既定のプロパティを使用して初期化します。Initializes a new instance of the Mutex class with default properties.

Mutex(Boolean)

呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示す Boolean 型の値を使用して、Mutex クラスの新しいインスタンスを初期化します。Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex.

Mutex(Boolean, String)

呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示す Boolean 型の値と、ミューテックスの名前を表す文字列を使用して、Mutex クラスの新しいインスタンスを初期化します。Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, and a string that is the name of the mutex.

Mutex(Boolean, String, Boolean)

呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値、ミューテックスの名前を表す文字列、およびメソッドから戻るときにミューテックスの初期所有権が呼び出し元のスレッドに付与されたかどうかを示すブール値を指定して、Mutex クラスの新しいインスタンスを初期化します。Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex.

Mutex(Boolean, String, Boolean, MutexSecurity)

呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値、ミューテックスの名前を表す文字列、メソッドが戻るときにミューテックスの初期所有権が呼び出し元のスレッドに付与されたかどうかを示すブール値変数、および名前付きミューテックスに適用するアクセス制御セキュリティを指定して、Mutex クラスの新しいインスタンスを初期化します。Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, a Boolean variable that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex, and the access control security to be applied to the named mutex.

フィールド

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()

名前付きミューテックスのアクセス制御セキュリティを表す MutexSecurity オブジェクトを取得します。Gets a MutexSecurity object that represents the access control security for the named mutex.

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 mutex, if it already exists.

OpenExisting(String, MutexRights)

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

ReleaseMutex()

Mutex を一度解放します。Releases the Mutex once.

SetAccessControl(MutexSecurity)

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

ToString()

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

(継承元 Object)
TryOpenExisting(String, Mutex)

既に存在する場合は、指定した名前付きミューテックスを開き操作が成功したかどうかを示す値を返します。Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, MutexRights, Mutex)

既に存在する場合は、必要なセキュリティ アクセスを使用して指定した名前付きミューテックスを開き、操作が成功したかどうかを示す値を返します。Opens the specified named mutex, 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)

現在の 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.

(継承元 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(Mutex)
SetAccessControl(Mutex, MutexSecurity)
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.

こちらもご覧ください