Mutex Class

定義

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

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Mutex : System.Threading.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. 型の直接 dispose を呼び出してそのDisposeメソッド、 try / catchブロックします。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またはtimeoutパラメーターが経過しました。The 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.WaitAllWaitHandle.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 version 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. その名前がプレフィックスで始まる場合は、"ローカル\"、ミュー テックスが作成されたにターミナル サーバー セッションでのみ表示されます。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. プレフィックスがかかる場合、名前付きミュー テックスを作成するときに、プレフィックスを指定しないと、"ローカル\"。If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". ターミナル サーバー セッション内で名前のプレフィックスのみが異なる 2 つのミュー テックスは別のミュー テックス、および両方は、ターミナル サーバー セッションですべてのプロセスを表示します。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\"と"ローカル\"ミュー テックスの名前のプロセスは、ターミナル サーバー セッションを基準のスコープについて説明します。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)

呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値を使用して、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)

呼び出し元のスレッドにミューテックスの初期所有権があるかどうかを示すブール値と、ミューテックスの名前を表す文字列を使用して、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.

方法

Close()

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

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

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

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

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

(Inherited from Object)
GetAccessControl()

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

GetHashCode()

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

(Inherited from Object)
GetLifetimeService()

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

(Inherited from MarshalByRefObject)
GetType()

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

(Inherited from Object)
InitializeLifetimeService()

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

(Inherited from MarshalByRefObject)
MemberwiseClone()

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

(Inherited from Object)
MemberwiseClone(Boolean)

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

(Inherited from 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.

(Inherited from 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.

(Inherited from 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.

(Inherited from 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.

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

現在のインスタンスがシグナルを受信するまで現在のスレッドをブロックします。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

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

(Inherited from WaitHandle)
SafeWaitHandle

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

(Inherited from WaitHandle)

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

IDisposable.Dispose() Inherited from WaitHandle

フィールド

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)

適用対象

スレッド セーフ

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

こちらもご覧ください