Mutex Osztály

Definíció

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

Öröklődés

Object

WaitHandle

Mutex

Öröklődés

Object

MarshalByRefObject

WaitHandle

Mutex

Attribútumok

ComVisibleAttribute

Példák

Ez a példa bemutatja, hogyan szinkronizálja egy helyi Mutex objektum a védett erőforráshoz való hozzáférést. Mivel az egyes hívószálak mindaddig le vannak tiltva, amíg meg nem szerzi a mutex tulajdonjogát, meg kell hívnia a metódust a ReleaseMutex mutex tulajdonjogának felszabadításához.

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

Az alábbi példában minden szál meghívja a metódust a WaitOne(Int32) mutex beszerzéséhez. Ha az időtúllépési időköz eltelik, a metódus visszatér false, és a szál nem szerzi be a mutexet, és nem fér hozzá a mutex által védett erőforráshoz. A ReleaseMutex metódust csak az a szál hívja meg, amely a mutexet szerzi be.

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

Megjegyzések

Ha két vagy több szálnak egyszerre kell hozzáférnie egy megosztott erőforráshoz, a rendszernek szinkronizálási mechanizmusra van szüksége annak biztosításához, hogy egyszerre csak egy szál használja az erőforrást. Mutex egy olyan szinkronizálási primitív, amely kizárólagos hozzáférést biztosít a megosztott erőforráshoz csak egy szálhoz. Ha egy szál mutexet szerez be, a második szál, amely meg szeretné szerezni a mutexet, fel lesz függesztve, amíg az első szál fel nem oldja a mutexet.

A metódussal kérheti a WaitHandle.WaitOne mutex tulajdonjogát. A hívószál az alábbi műveletek egyikéig blokkolja a hívó szálat:

• A mutex jelzése azt jelzi, hogy nem a tulajdonosa. Ha ez történik, a WaitOne metódus visszatér true, és a hívó szál a mutex tulajdonjogát feltételezi, és hozzáfér a mutex által védett erőforráshoz. Ha befejezte az erőforrás elérését, a szálnak meg kell hívnia a ReleaseMutex metódust a mutex tulajdonjogának felszabadításához. A Példák szakaszban szereplő első példa ezt a mintát szemlélteti.
• A metódus meghívásában WaitOne megadott időtúllépési időköz, amely egy vagy millisecondsTimeout több paraméterrel rendelkeziktimeout. Amikor ez történik, a WaitOne metódus visszatér false, és a hívó szál nem tesz további kísérletet a mutex tulajdonjogának megszerzésére. Ebben az esetben úgy kell strukturálnia a kódot, hogy a mutex által védett erőforráshoz való hozzáférés megtagadva legyen a hívó szálhoz. Mivel a szál soha nem szerezte meg a mutex tulajdonjogát, nem nevezheti a metódust ReleaseMutex . A Példák szakaszban található második példa ezt a mintát szemlélteti.

Az Mutex osztály kikényszeríti a szál identitását, így a mutexet csak az azt beszerző szál szabadíthatja fel. Ezzel szemben az osztály nem kényszeríti a Semaphore szálidentitást. A mutex át is adható az alkalmazás tartományhatárai között.

A mutexet birtokoló szál az ismétlődő hívások során ugyanazt a mutexet kérheti le anélkül, hogy WaitOne a végrehajtást akadályoznák. A szálnak azonban ugyanannyi alkalommal kell meghívnia a ReleaseMutex metódust a mutex tulajdonjogának felszabadításához.

Mivel az osztály öröklődikMutexWaitHandle, meghívhatja a statikus WaitHandle.WaitAll és WaitHandle.WaitAny a metódusokat is a védett erőforrásokhoz való hozzáférés szinkronizálásához.

Ha egy szál leáll egy mutex birtoklása közben, a mutex azt mondják, hogy elhagyják. A mutex állapota jelzésre van állítva, és a következő várakozási szál tulajdonjogot kap. A .NET-keretrendszer 2.0-s verziójától kezdve egy AbandonedMutexException kerül a következő szálba, amely az elhagyott mutexet szerzi be. A .NET-keretrendszer 2.0-s verziója előtt nem történt kivétel.

Rendszerszintű mutex esetén egy elhagyott mutex azt jelezheti, hogy egy alkalmazás hirtelen leállt (például a Windows Task Manager használatával).

A mutexek két típusból állnak: a helyi mutexek, amelyek névtelenek, és nevesített rendszer-mutexek. Egy helyi mutex csak a programfolyamaton belül létezik. A folyamatot bármely olyan szál használhatja, amely hivatkozik a Mutex mutexet képviselő objektumra. Minden névtelen Mutex objektum egy külön helyi mutexet jelöl.

A névvel ellátott rendszer-mutexek az operációs rendszer egészében láthatók, és a folyamatok tevékenységeinek szinkronizálására használhatók. Egy névvel rendelkező konstruktor használatával létrehozhat egy Mutex nevet elfogadó objektumot, amely egy elnevezett rendszer-mutexet jelöl. Az operációsrendszer-objektum létrehozható egyszerre, vagy létezhet az objektum létrehozása Mutex előtt. Több Mutex objektumot is létrehozhat, amelyek ugyanazt a névvel ellátott rendszer-mutexet jelölik, és a OpenExisting metódus használatával megnyithat egy meglévő elnevezett rendszer-mutexet.

A fordított perjel (\) egy fenntartott karakter a mutex nevében. Ne használjon fordított perjelet (\) a mutex nevében, kivéve azt a megjegyzést, amely a mutexek terminálkiszolgáló-munkamenetekben való használatára vonatkozó megjegyzésben van megadva. Ellenkező esetben előfordulhat, hogy a DirectoryNotFoundException rendszer egy meglévő fájlt jelöl, annak ellenére, hogy a mutex neve egy meglévő fájlt jelöl.

Szálbiztonság

Ez a típus szálbiztos.

Lásd még

• WaitHandle
• Thread
• felügyelt szálkezelés
• Mutexes