Mutex クラス

定義

public ref class Mutex sealed : System::Threading::WaitHandle

public sealed class Mutex : System.Threading.WaitHandle

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Mutex : System.Threading.WaitHandle

type Mutex = class
    inherit WaitHandle

[<System.Runtime.InteropServices.ComVisible(true)>]
type Mutex = class
    inherit WaitHandle

Public NotInheritable Class Mutex
Inherits WaitHandle

継承

Object

WaitHandle

Mutex

継承

Object

MarshalByRefObject

WaitHandle

Mutex

属性

ComVisibleAttribute

例

この例では、ローカル Mutex オブジェクトを使用して、保護されたリソースへのアクセスを同期する方法を示します。 各呼び出し元スレッドはミューテックスの所有権を取得するまでブロックされるため、ミューテックスの所有権を解放するには、 ReleaseMutex メソッドを呼び出す必要があります。

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) メソッドを呼び出してミューテックスを取得します。 タイムアウト間隔が経過すると、メソッドは falseを返し、スレッドはミューテックスを取得せず、ミューテックスが保護するリソースへのアクセスも取得しません。 ReleaseMutex メソッドは、ミューテックスを取得するスレッドによってのみ呼び出されます。

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 つのスレッドのみがリソースを使用するように同期メカニズムが必要です。 Mutex は、共有リソースへの排他アクセスを 1 つのスレッドのみに付与する同期プリミティブです。 スレッドがミューテックスを取得した場合、そのミューテックスを取得する 2 番目のスレッドは、最初のスレッドがミューテックスを解放するまで中断されます。

WaitHandle.WaitOne メソッドを使用して、ミューテックスの所有権を要求できます。 呼び出し元のスレッドは、次のいずれかが発生するまでブロックします。

• ミューテックスは、所有されていないことを示すために通知されます。 この場合、 WaitOne メソッドは trueを返し、呼び出し元のスレッドはミューテックスの所有権を引き受け、ミューテックスによって保護されたリソースにアクセスします。 リソースへのアクセスが完了したら、スレッドは ReleaseMutex メソッドを呼び出してミューテックスの所有権を解放する必要があります。 「例」セクションの最初の例は、このパターンを示しています。

• millisecondsTimeoutまたは timeout パラメーターを持つWaitOne メソッドの呼び出しで指定されたタイムアウト間隔が経過しました。 この場合、 WaitOne メソッドは falseを返し、呼び出し元のスレッドはミューテックスの所有権の取得をこれ以上試行しません。 この場合、ミューテックスによって保護されているリソースへのアクセスが呼び出し元のスレッドに対して拒否されるようにコードを構成する必要があります。 スレッドはミューテックスの所有権を取得しなかったため、 ReleaseMutex メソッドを呼び出してはなりません。 「例」セクションの 2 番目の例は、このパターンを示しています。

Mutex クラスはスレッド ID を適用するため、ミューテックスは取得したスレッドのみが解放できます。 これに対し、 Semaphore クラスではスレッド ID は適用されません。 ミューテックスは、アプリケーション ドメインの境界を越えて渡すこともできます。

ミューテックスを所有するスレッドは、実行をブロックすることなく、 WaitOne の繰り返し呼び出しで同じミューテックスを要求できます。 ただし、ミューテックスの所有権を解放するには、スレッドが同じ回数だけ ReleaseMutex メソッドを呼び出す必要があります。

Mutex クラスはWaitHandleから継承されるため、静的WaitHandle.WaitAllメソッドとWaitHandle.WaitAny メソッドを呼び出して、保護されたリソースへのアクセスを同期することもできます。

ミューテックスの所有中にスレッドが終了すると、ミューテックスは破棄されると言われます。 ミューテックスの状態がシグナル通知に設定され、次の待機中のスレッドが所有権を取得します。 .NET Framework のバージョン 2.0 以降では、破棄されたミューテックスを取得する次のスレッドで AbandonedMutexException がスローされます。 .NET Framework のバージョン 2.0 より前では、例外はスローされませんでした。

システム全体のミューテックスの場合、破棄されたミューテックスは、アプリケーションが突然終了したことを示している可能性があります (たとえば、Windows タスク マネージャーを使用)。

ミューテックスは、名前のないローカル ミューテックスと名前付きシステム ミューテックスの 2 種類です。 ローカル ミューテックスは、プロセス内にのみ存在します。 ミューテックスを表す Mutex オブジェクトへの参照を持つプロセス内の任意のスレッドで使用できます。 名前のない各 Mutex オブジェクトは、個別のローカル ミューテックスを表します。

名前付きシステム ミューテックスはオペレーティング システム全体で表示され、プロセスのアクティビティを同期するために使用できます。 名前を受け取るコンストラクターを使用して、名前付きシステム ミューテックスを表す Mutex オブジェクトを作成できます。 オペレーティング システム オブジェクトは、同時に作成することも、 Mutex オブジェクトを作成する前に存在することもできます。 同じ名前付きシステム ミューテックスを表す複数の Mutex オブジェクトを作成でき、 OpenExisting メソッドを使用して既存の名前付きシステム ミューテックスを開くことができます。

円記号 (\) はミューテックス名の予約文字です。 ターミナル サーバー セッションでのミューテックスの使用に関するメモで指定されている場合を除き、ミューテックス名に円記号 (\) を使用しないでください。 それ以外の場合は、ミューテックスの名前が既存のファイルを表している場合でも、 DirectoryNotFoundException がスローされる可能性があります。

スレッド セーフ

この型はスレッド セーフです。

こちらもご覧ください

• WaitHandle
• Thread
• マネージド スレッド処理
• ミューテックス