Freigeben über


Mutex Konstruktoren

Definition

Initialisiert eine neue Instanz der Mutex-Klasse.

Überlädt

Mutex()

Initialisiert eine neue Instanz der Mutex-Klasse mit Standardeigenschaften.

Mutex(Boolean)

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll.

Mutex(Boolean, String)

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, sowie mit einer Zeichenfolge, die den Namen des Mutex darstellt.

Mutex(Boolean, String, Boolean)

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, mit einer Zeichenfolge mit dem Namen des Mutex sowie mit einem booleschen Wert, der beim Beenden der Methode angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex gewährt wurde.

Mutex(Boolean, String, Boolean, MutexSecurity)

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, mit einer Zeichenfolge mit dem Namen des Mutex, mit einer booleschen Variable, die beim Beenden der Methode angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex gewährt wurde, und mit der Zugriffssteuerungssicherheit, die auf den benannten Mutex angewendet werden soll.

Mutex()

Quelle:
Mutex.cs
Quelle:
Mutex.cs
Quelle:
Mutex.cs

Initialisiert eine neue Instanz der Mutex-Klasse mit Standardeigenschaften.

public:
 Mutex();
public Mutex ();
Public Sub New ()

Beispiele

Das folgende Codebeispiel zeigt, wie ein lokales Mutex Objekt verwendet wird, um den Zugriff auf eine geschützte Ressource zu synchronisieren. Der Thread, der den Mutex erstellt, besitzt ihn zunächst nicht.

// This example shows how a Mutex is used to synchronize access
// to a protected resource. Unlike Monitor, Mutex can be used with
// WaitHandle.WaitAll and WaitAny, and can be passed across
// AppDomain boundaries.
using namespace System;
using namespace System::Threading;
const int numIterations = 1;
const int numThreads = 3;
ref class Test
{
public:

   // Create a new Mutex. The creating thread does not own the
   // Mutex.
   static Mutex^ mut = gcnew Mutex;
   static void MyThreadProc()
   {
      for ( int i = 0; i < numIterations; i++ )
      {
         UseResource();

      }
   }


private:

   // This method represents a resource that must be synchronized
   // so that only one thread at a time can enter.
   static void UseResource()
   {
      
      //Wait until it is OK to enter.
      mut->WaitOne();
      Console::WriteLine( "{0} has entered protected the area", Thread::CurrentThread->Name );
      
      // Place code to access non-reentrant resources here.
      // Simulate some work.
      Thread::Sleep( 500 );
      Console::WriteLine( "{0} is leaving protected the area\r\n", Thread::CurrentThread->Name );
      
      // Release the Mutex.
      mut->ReleaseMutex();
   }

};

int main()
{
   
   // Create the threads that will use the protected resource.
   for ( int i = 0; i < numThreads; i++ )
   {
      Thread^ myThread = gcnew Thread( gcnew ThreadStart( Test::MyThreadProc ) );
      myThread->Name = String::Format( "Thread {0}", i + 1 );
      myThread->Start();

   }
   
   // The main thread exits, but the application continues to 
   // run until all foreground threads have exited.
}
// This example shows how a Mutex is used to synchronize access
// to a protected resource. Unlike Monitor, Mutex can be used with
// WaitHandle.WaitAll and WaitAny, and can be passed across
// AppDomain boundaries.
 
using System;
using System.Threading;

class Test13
{
    // 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 myThread = new Thread(new ThreadStart(MyThreadProc));
            myThread.Name = String.Format("Thread{0}", i + 1);
            myThread.Start();
        }

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

    private static void MyThreadProc()
    {
        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.
        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\r\n", 
            Thread.CurrentThread.Name);
         
        // Release the Mutex.
        mut.ReleaseMutex();
    }
}
' This example shows how a Mutex is used to synchronize access
' to a protected resource. Unlike Monitor, Mutex can be used with
' WaitHandle.WaitAll and WaitAny, and can be passed across
' AppDomain boundaries.
 
Imports System.Threading

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

    <MTAThread> _
    Shared Sub Main()
        ' Create the threads that will use the protected resource.
        Dim i As Integer
        For i = 1 To numThreads
            Dim myThread As New Thread(AddressOf MyThreadProc)
            myThread.Name = [String].Format("Thread{0}", i)
            myThread.Start()
        Next i

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

    End Sub

    Private Shared Sub MyThreadProc()
        Dim i As Integer
        For i = 1 To numIterations
            UseResource()
        Next i
    End Sub

    ' This method represents a resource that must be synchronized
    ' so that only one thread at a time can enter.
    Private Shared Sub UseResource()
        ' Wait until it is safe to enter.
        mut.WaitOne()

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

        ' Place code to access non-reentrant resources here.

        ' Simulate some work
        Thread.Sleep(500)

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

        ' Release Mutex.
        mut.ReleaseMutex()
    End Sub
End Class

Hinweise

Das Aufrufen dieser Konstruktorüberladung ist identisch mit dem Aufrufen der Mutex(Boolean) Konstruktorüberladung und dem Angeben false für den anfänglichen Besitz des Mutex. Das heißt, der aufrufende Thread besitzt den Mutex nicht.

Weitere Informationen

Gilt für:

Mutex(Boolean)

Quelle:
Mutex.cs
Quelle:
Mutex.cs
Quelle:
Mutex.cs

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll.

public:
 Mutex(bool initiallyOwned);
public Mutex (bool initiallyOwned);
new System.Threading.Mutex : bool -> System.Threading.Mutex
Public Sub New (initiallyOwned As Boolean)

Parameter

initiallyOwned
Boolean

true, um dem aufrufenden Thread den anfänglichen Besitz des Mutex zuzuweisen, andernfalls false.

Beispiele

Das folgende Codebeispiel zeigt, wie ein lokales Mutex Objekt verwendet wird, um den Zugriff auf eine geschützte Ressource zu synchronisieren. Der Thread, der erstellt Mutex , besitzt ihn zunächst.

using namespace System;
using namespace System::Threading;

const int numIterations = 1;
const int numThreads = 3;

ref class Test
{
public:

   // Create a new Mutex. The creating thread owns the
   // Mutex.
   static Mutex^ mut = gcnew Mutex( true );
   static void MyThreadProc()
   {
      for ( int i = 0; i < numIterations; i++ )
      {
         UseResource();

      }
   }


private:

   // This method represents a resource that must be synchronized
   // so that only one thread at a time can enter.
   static void UseResource()
   {
      
      //Wait until it is OK to enter.
      mut->WaitOne();
      Console::WriteLine( "{0} has entered protected the area", Thread::CurrentThread->Name );
      
      // Place code to access non-reentrant resources here.
      // Simulate some work.
      Thread::Sleep( 500 );
      Console::WriteLine( "{0} is leaving protected the area\r\n", Thread::CurrentThread->Name );
      
      // Release the Mutex.
      mut->ReleaseMutex();
   }

};

int main()
{
   
   // Initialize the Mutex.
   Mutex^ mut = Test::mut;
   
   // Create the threads that will use the protected resource.
   for ( int i = 0; i < numThreads; i++ )
   {
      Thread^ myThread = gcnew Thread( gcnew ThreadStart( Test::MyThreadProc ) );
      myThread->Name = String::Format( "Thread {0}", i + 1 );
      myThread->Start();

   }
   
   // Wait one second before allowing other threads to
   // acquire the Mutex.
   Console::WriteLine( "Creating thread owns the Mutex." );
   Thread::Sleep( 1000 );
   Console::WriteLine( "Creating thread releases the Mutex.\r\n" );
   mut->ReleaseMutex();
}
// The example displays output like the following:
//       Creating thread owns the Mutex.
//       Creating thread releases the Mutex.
//       
//       Thread1 has entered the protected area
//       Thread1 is leaving the protected area
//       
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
using System;
using System.Threading;

class Test
{
    private static Mutex mut;
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create a new Mutex. The creating thread owns the Mutex.
        mut = new Mutex(true);
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread myThread = new Thread(new ThreadStart(MyThreadProc));
            myThread.Name = String.Format("Thread{0}", i + 1);
            myThread.Start();
        }

        // Wait one second before allowing other threads to
        // acquire the Mutex.
        Console.WriteLine("Creating thread owns the Mutex.");
        Thread.Sleep(1000);

        Console.WriteLine("Creating thread releases the Mutex.\r\n");
        mut.ReleaseMutex();
    }

    private static void MyThreadProc()
    {
        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.
        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\r\n", 
            Thread.CurrentThread.Name);
         
        // Release the Mutex.
        mut.ReleaseMutex();
    }
}
// The example displays output like the following:
//       Creating thread owns the Mutex.
//       Creating thread releases the Mutex.
//       
//       Thread1 has entered the protected area
//       Thread1 is leaving the protected area
//       
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
Imports System.Threading

Class Test
    ' Create a new Mutex. The creating thread owns the
    ' Mutex.
    Private Shared mut As New Mutex(True)
    Private Const numIterations As Integer = 1
    Private Const numThreads As Integer = 3

    <MTAThread> _
    Shared Sub Main()
        ' Create the threads that will use the protected resource.
        Dim i As Integer
        For i = 1 To numThreads
            Dim myThread As New Thread(AddressOf MyThreadProc)
            myThread.Name = [String].Format("Thread{0}", i)
            myThread.Start()
        Next i

        ' Wait one second before allowing other threads to
        ' acquire the Mutex.
        Console.WriteLine("Creating thread owns the Mutex.")
        Thread.Sleep(1000)

        Console.WriteLine("Creating thread releases the Mutex." & vbCrLf)
        mut.ReleaseMutex()
    End Sub

    Private Shared Sub MyThreadProc()
        Dim i As Integer
        For i = 1 To numIterations
            UseResource()
        Next i
    End Sub

    ' This method represents a resource that must be synchronized
    ' so that only one thread at a time can enter.
    Private Shared Sub UseResource()
        ' Wait until it is safe to enter.
        mut.WaitOne()

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

        ' Place code to access non-reentrant resources here.

        ' Simulate some work
        Thread.Sleep(500)

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

        ' Release Mutex.
        mut.ReleaseMutex()
    End Sub
End Class
' The example displays output like the following:
'       Creating thread owns the Mutex.
'       Creating thread releases the Mutex.
'       
'       Thread1 has entered the protected area
'       Thread1 is leaving the protected area
'       
'       Thread2 has entered the protected area
'       Thread2 is leaving the protected area
'       
'       Thread3 has entered the protected area
'       Thread3 is leaving the protected area

Weitere Informationen

Gilt für:

Mutex(Boolean, String)

Quelle:
Mutex.cs
Quelle:
Mutex.cs
Quelle:
Mutex.cs

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, sowie mit einer Zeichenfolge, die den Namen des Mutex darstellt.

public:
 Mutex(bool initiallyOwned, System::String ^ name);
[System.Security.SecurityCritical]
public Mutex (bool initiallyOwned, string name);
public Mutex (bool initiallyOwned, string? name);
public Mutex (bool initiallyOwned, string name);
[<System.Security.SecurityCritical>]
new System.Threading.Mutex : bool * string -> System.Threading.Mutex
new System.Threading.Mutex : bool * string -> System.Threading.Mutex
Public Sub New (initiallyOwned As Boolean, name As String)

Parameter

initiallyOwned
Boolean

true, um dem aufrufenden Thread den anfänglichen Besitz des benannten Systemmutex zuzuweisen, wenn der benannte Systemmutex als Ergebnis dieses Aufrufs erstellt wird, andernfalls false.

name
String

Der Name, wenn das Synchronisierungsobjekt für andere Prozesse freigegeben werden soll; andernfalls null oder eine leere Zeichenfolge. Bei dem Namen wird die Groß- und Kleinschreibung berücksichtigt. Der umgekehrte Schrägstrich (\) ist reserviert und kann nur zum Angeben eines Namespace verwendet werden. Weitere Informationen zu Namespaces finden Sie im Abschnitt Hinweise. Je nach Betriebssystem kann es weitere Einschränkungen für den Namen geben. Unter Unix-basierten Betriebssystemen muss der Name nach dem Ausschluss des Namespace beispielsweise ein gültiger Dateiname sein.

Attribute

Ausnahmen

Das benannte Mutex ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über FullControl.

name ist ungültig. Dies kann aus verschiedenen Gründen der Fall sein, z. B. durch Einschränkungen, die vom Betriebssystem auferlegt werden, etwa ein unbekanntes Präfix oder ungültige Zeichen. Beachten Sie, dass bei dem Namen und den gängigen Präfixen "Global\" und "Local\" die Groß-/Kleinschreibung beachtet wird.

- oder -

Es ist ein anderer Fehler aufgetreten. DieHResult-Eigenschaft stellt möglicherweise weitere Informationen zur Verfügung.

Nur Windows: name hat einen unbekannten Namespace angegeben. Weitere Informationen finden Sie unter Objektnamen.

name ist zu lang. Längeneinschränkungen können vom Betriebssystem oder der Konfiguration abhängen.

Ein Synchronisierungsobjekt mit dem angegebenen name kann nicht erstellt werden. Ein Synchronisierungsobjekt eines anderen Typs weist ggf. denselben Namen auf.

Nur .NET Framework: name ist länger als MAX_PATH (260 Zeichen).

Beispiele

Das folgende Beispiel zeigt, wie ein benannter Mutex verwendet wird, um zwischen Threads zu signalisieren, die in zwei separaten Prozessen ausgeführt werden.

Führen Sie dieses Programm über zwei oder mehr Befehlsfenster aus. Jeder Prozess erstellt ein Mutex -Objekt, das den benannten mutex MyMutexdarstellt. Der benannte Mutex ist ein Systemobjekt, dessen Lebensdauer durch die Lebensdauer der Objekte begrenzt wird, die Mutex es darstellen. Der benannte Mutex wird erstellt, wenn der erste Prozess sein Mutex Objekt erstellt. In diesem Beispiel gehört der benannte Mutex dem ersten Prozess, der das Programm ausführt. Der benannte Mutex wird zerstört, wenn alle Objekte, die Mutex ihn darstellen, freigegeben wurden.

Die in diesem Beispiel verwendete Konstruktorüberladung kann dem aufrufenden Thread nicht mitteilen, ob der ursprüngliche Besitz des benannten Mutex gewährt wurde. Sie sollten diesen Konstruktor nicht verwenden, um den ursprünglichen Besitz anzufordern, es sei denn, Sie können sicher sein, dass der Thread den benannten Mutex erstellt.

using namespace System;
using namespace System::Threading;

int main()
{
   // Create the named mutex. Only one system object named 
   // "MyMutex" can exist; the local Mutex object represents 
   // this system object, regardless of which process or thread
   // caused "MyMutex" to be created.
   Mutex^ m = gcnew Mutex( false,"MyMutex" );
   
   // Try to gain control of the named mutex. If the mutex is 
   // controlled by another thread, wait for it to be released.        
   Console::WriteLine(  "Waiting for the Mutex." );
   m->WaitOne();
   
   // Keep control of the mutex until the user presses
   // ENTER.
   Console::WriteLine( "This application owns the mutex. "
   "Press ENTER to release the mutex and exit." );
   Console::ReadLine();
   m->ReleaseMutex();
}
using System;
using System.Threading;

public class Test1
{
    public static void Main()
    {
        // Create the named mutex. Only one system object named 
        // "MyMutex" can exist; the local Mutex object represents 
        // this system object, regardless of which process or thread
        // caused "MyMutex" to be created.
        Mutex m = new Mutex(false, "MyMutex");
        
        // Try to gain control of the named mutex. If the mutex is 
        // controlled by another thread, wait for it to be released.        
        Console.WriteLine("Waiting for the Mutex.");
        m.WaitOne();

        // Keep control of the mutex until the user presses
        // ENTER.
        Console.WriteLine("This application owns the mutex. " +
            "Press ENTER to release the mutex and exit.");
        Console.ReadLine();

        m.ReleaseMutex();
    }
}
Imports System.Threading

Public Class Test
   Public Shared Sub Main()
      ' Create the named mutex. Only one system object named 
      ' "MyMutex" can exist; the local Mutex object represents 
      ' this system object, regardless of which process or thread
      ' caused "MyMutex" to be created.
      Dim m As New Mutex(False, "MyMutex")
      
      ' Try to gain control of the named mutex. If the mutex is 
      ' controlled by another thread, wait for it to be released.        
      Console.WriteLine("Waiting for the Mutex.")
      m.WaitOne()
      
      ' Keep control of the mutex until the user presses
      ' ENTER.
      Console.WriteLine("This application owns the mutex. " _
          & "Press ENTER to release the mutex and exit.")
      Console.ReadLine()
      
      m.ReleaseMutex()
   End Sub 
End Class

Hinweise

Der name kann mit Global\ dem Präfix oder Local\ versehen sein, um einen Namespace anzugeben. Wenn der Global Namespace angegeben wird, kann das Synchronisierungsobjekt für alle Prozesse im System freigegeben werden. Wenn der Local Namespace angegeben ist, was auch der Standardwert ist, wenn kein Namespace angegeben wird, kann das Synchronisierungsobjekt für Prozesse in derselben Sitzung freigegeben werden. Unter Windows ist eine Sitzung eine Anmeldesitzung, und Dienste werden in der Regel in einer anderen nicht interaktiven Sitzung ausgeführt. Unter Unix-ähnlichen Betriebssystemen verfügt jede Shell über eine eigene Sitzung. Sitzungslokale Synchronisierungsobjekte eignen sich möglicherweise für die Synchronisierung zwischen Prozessen mit einer übergeordneten/untergeordneten Beziehung, bei der sie alle in derselben Sitzung ausgeführt werden. Weitere Informationen zu Synchronisierungsobjektnamen unter Windows finden Sie unter Objektnamen.

Wenn ein name bereitgestellt wird und bereits ein Synchronisierungsobjekt des angeforderten Typs im Namespace vorhanden ist, wird das vorhandene Synchronisierungsobjekt verwendet. Wenn im Namespace bereits ein Synchronisierungsobjekt eines anderen Typs vorhanden ist, wird ein WaitHandleCannotBeOpenedException ausgelöst. Andernfalls wird ein neues Synchronisierungsobjekt erstellt.

Wenn name nicht null und initiallyOwned ist, besitzt trueder aufrufende Thread den Mutex nur, wenn der benannte Systemmutex als Ergebnis dieses Aufrufs erstellt wurde. Da es keinen Mechanismus gibt, um zu bestimmen, ob der benannte Systemmutex erstellt wurde, ist es besser, für initiallyOwned anzugebenfalse, wenn diese Konstruktorüberladung aufgerufen wird. Sie können den Mutex(Boolean, String, Boolean) Konstruktor verwenden, wenn Sie den ursprünglichen Besitz bestimmen müssen.

Dieser Konstruktor initialisiert ein Mutex Objekt, das einen benannten Systemmutex darstellt. Sie können mehrere Mutex Objekte erstellen, die denselben benannten Systemmutex darstellen.

Wenn der benannte Mutex bereits mit Zugriffssteuerungssicherheit erstellt wurde und der Aufrufer nicht verfügt MutexRights.FullControl, wird eine Ausnahme ausgelöst. Informationen zum Öffnen eines vorhandenen benannten Mutex mit nur den Berechtigungen, die für die Synchronisierung von Threadaktivitäten erforderlich sind, finden Sie in der OpenExisting -Methode.

Wenn Sie eine leere Zeichenfolge für nameangebennull, wird ein lokaler Mutex erstellt, als hätten Sie den Mutex(Boolean) Konstruktor aufgerufen. In diesem Fall createdNew ist immer true.

Da sie systemweit sind, können benannte Mutexes verwendet werden, um die Ressourcennutzung über Prozessgrenzen hinweg zu koordinieren.

Hinweis

Auf einem Server, auf dem Terminaldienste ausgeführt werden, kann ein benannter Systemmutex zwei Sichtbarkeitsebenen aufweisen. Wenn sein Name mit dem Präfix Global\beginnt, ist der Mutex in allen Terminalserversitzungen sichtbar. Wenn sein Name mit dem Präfix Local\beginnt, ist der Mutex nur in der Terminalserversitzung sichtbar, in der er erstellt wurde. In diesem Fall kann in jeder der anderen Terminalserversitzungen auf dem Server ein separater Mutex mit demselben Namen vorhanden sein. Wenn Sie beim Erstellen eines benannten Mutex kein Präfix angeben, wird das Präfix Local\verwendet. Innerhalb einer Terminalserversitzung sind zwei Mutexe, deren Namen sich nur durch ihre Präfixe unterscheiden, separate Mutexe, und beide sind für alle Prozesse in der Terminalserversitzung sichtbar. Das heißt, die Präfixnamen Global\ und Local\ beschreiben den Bereich des Mutexnamens relativ zu Terminalserversitzungen, nicht relativ zu Prozessen.

Achtung

Standardmäßig ist ein benannter Mutex nicht auf den Benutzer beschränkt, der ihn erstellt hat. Andere Benutzer können den Mutex möglicherweise öffnen und verwenden, einschließlich der Störung des Mutex, indem sie den Mutex eingeben und ihn nicht verlassen. Unter Unix-ähnlichen Betriebssystemen wird das Dateisystem bei der Implementierung von benannten Mutexes verwendet, und andere Benutzer können in der Lage sein, benannte Mutexes auf größere Weise zu beeinträchtigen. Wenn Sie unter Windows den Zugriff auf bestimmte Benutzer einschränken möchten, können Sie eine Konstruktorüberladung oder MutexAcl einen MutexSecurity verwenden und beim Erstellen des benannten Mutex übergeben. Unter Unix-ähnlichen Betriebssystemen gibt es derzeit keine Möglichkeit, den Zugriff auf einen benannten Mutex einzuschränken. Vermeiden Sie die Verwendung benannter Mutexes ohne Zugriffsbeschränkungen auf Systemen, auf denen möglicherweise nicht vertrauenswürdige Benutzer Code ausführen.

Der umgekehrte Schrägstrich (\) ist ein reserviertes Zeichen in einem Mutex-Namen. Verwenden Sie keinen umgekehrten Schrägstrich (\) in einem Mutex-Namen, außer wie im Hinweis zur Verwendung von Mutexes in Terminalserversitzungen angegeben. Andernfalls kann sogar eine DirectoryNotFoundException ausgelöst werden, wenn der Mutex-Name für eine bereits vorhandene Datei steht.

Weitere Informationen

Gilt für:

Mutex(Boolean, String, Boolean)

Quelle:
Mutex.cs
Quelle:
Mutex.cs
Quelle:
Mutex.cs

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, mit einer Zeichenfolge mit dem Namen des Mutex sowie mit einem booleschen Wert, der beim Beenden der Methode angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex gewährt wurde.

public:
 Mutex(bool initiallyOwned, System::String ^ name, [Runtime::InteropServices::Out] bool % createdNew);
[System.Security.SecurityCritical]
public Mutex (bool initiallyOwned, string name, out bool createdNew);
public Mutex (bool initiallyOwned, string? name, out bool createdNew);
public Mutex (bool initiallyOwned, string name, out bool createdNew);
[<System.Security.SecurityCritical>]
new System.Threading.Mutex : bool * string * bool -> System.Threading.Mutex
new System.Threading.Mutex : bool * string * bool -> System.Threading.Mutex
Public Sub New (initiallyOwned As Boolean, name As String, ByRef createdNew As Boolean)

Parameter

initiallyOwned
Boolean

true, um dem aufrufenden Thread den anfänglichen Besitz des benannten Systemmutex zuzuweisen, wenn der benannte Systemmutex als Ergebnis dieses Aufrufs erstellt wird, andernfalls false.

name
String

Der Name, wenn das Synchronisierungsobjekt für andere Prozesse freigegeben werden soll; andernfalls null oder eine leere Zeichenfolge. Bei dem Namen wird die Groß- und Kleinschreibung berücksichtigt. Der umgekehrte Schrägstrich (\) ist reserviert und kann nur zum Angeben eines Namespace verwendet werden. Weitere Informationen zu Namespaces finden Sie im Abschnitt Hinweise. Je nach Betriebssystem kann es weitere Einschränkungen für den Namen geben. Unter Unix-basierten Betriebssystemen muss der Name nach dem Ausschluss des Namespace beispielsweise ein gültiger Dateiname sein.

createdNew
Boolean

Enthält nach dem Beenden dieser Methode einen booleschen Wert, der true ist, wenn ein lokaler Mutex erstellt wurde (d. h. wenn name gleich null oder eine leere Zeichenfolge ist) oder wenn der angegebene benannte Systemmutex erstellt wurde. Der Wert ist false, wenn der angegebene benannte Systemmutex bereits vorhanden war. Dieser Parameter wird nicht initialisiert übergeben.

Attribute

Ausnahmen

Das benannte Mutex ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über FullControl.

name ist ungültig. Dies kann aus verschiedenen Gründen der Fall sein, z. B. durch Einschränkungen, die vom Betriebssystem auferlegt werden, etwa ein unbekanntes Präfix oder ungültige Zeichen. Beachten Sie, dass bei dem Namen und den gängigen Präfixen "Global\" und "Local\" die Groß-/Kleinschreibung beachtet wird.

- oder -

Es ist ein anderer Fehler aufgetreten. DieHResult-Eigenschaft stellt möglicherweise weitere Informationen zur Verfügung.

Nur Windows: name hat einen unbekannten Namespace angegeben. Weitere Informationen finden Sie unter Objektnamen.

name ist zu lang. Längeneinschränkungen können vom Betriebssystem oder der Konfiguration abhängen.

Ein Synchronisierungsobjekt mit dem angegebenen name kann nicht erstellt werden. Ein Synchronisierungsobjekt eines anderen Typs weist ggf. denselben Namen auf.

Nur .NET Framework: name ist länger als MAX_PATH (260 Zeichen).

Beispiele

Das folgende Codebeispiel zeigt, wie ein benannter Mutex verwendet wird, um zwischen Prozessen oder Threads zu signalisieren. Führen Sie dieses Programm über zwei oder mehr Befehlsfenster aus. Jeder Prozess erstellt ein Mutex Objekt, das den mutex "MyMutex" darstellt. Der benannte Mutex ist ein Systemobjekt. In diesem Beispiel wird ihre Lebensdauer durch die Lebensdauer der Objekte begrenzt, die Mutex sie darstellen. Der benannte Mutex wird erstellt, wenn der erste Prozess sein lokales Mutex Objekt erstellt, und wird zerstört, wenn alle Objekte, die Mutex ihn darstellen, freigegeben wurden. Der benannte Mutex gehört zunächst dem ersten Prozess. Der zweite Prozess und alle nachfolgenden Prozesse warten darauf, dass frühere Prozesse den benannten Mutex freigeben.

// This example shows how a named mutex is used to signal between
// processes or threads.
// Run this program from two (or more) command windows. Each process
// creates a Mutex object that represents the named mutex "MyMutex".
// The named mutex is a system object whose lifetime is bounded by the
// lifetimes of the Mutex objects that represent it. The named mutex
// is created when the first process creates its local Mutex; in this
// example, the named mutex is owned by the first process. The named 
// mutex is destroyed when all the Mutex objects that represent it
// have been released. 
// The second process (and any subsequent process) waits for earlier
// processes to release the named mutex.
using namespace System;
using namespace System::Threading;
int main()
{
   
   // Set this variable to false if you do not want to request 
   // initial ownership of the named mutex.
   bool requestInitialOwnership = true;
   bool mutexWasCreated;
   
   // Request initial ownership of the named mutex by passing
   // true for the first parameter. Only one system object named 
   // "MyMutex" can exist; the local Mutex object represents 
   // this system object. If "MyMutex" is created by this call,
   // then mutexWasCreated contains true; otherwise, it contains
   // false.
   Mutex^ m = gcnew Mutex( requestInitialOwnership, "MyMutex", mutexWasCreated );
   
   // This thread owns the mutex only if it both requested 
   // initial ownership and created the named mutex. Otherwise,
   // it can request the named mutex by calling WaitOne.
   if (  !(requestInitialOwnership && mutexWasCreated) )
   {
      Console::WriteLine(  "Waiting for the named mutex." );
      m->WaitOne();
   }

   
   // Once the process has gained control of the named mutex,
   // hold onto it until the user presses ENTER.
   Console::WriteLine(  "This process owns the named mutex. "
    "Press ENTER to release the mutex and exit." );
   Console::ReadLine();
   
   // Call ReleaseMutex to allow other threads to gain control
   // of the named mutex. If you keep a reference to the local
   // Mutex, you can call WaitOne to request control of the 
   // named mutex.
   m->ReleaseMutex();
}
// This example shows how a named mutex is used to signal between
// processes or threads.
// Run this program from two (or more) command windows. Each process
// creates a Mutex object that represents the named mutex "MyMutex".
// The named mutex is a system object whose lifetime is bounded by the
// lifetimes of the Mutex objects that represent it. The named mutex
// is created when the first process creates its local Mutex; in this
// example, the named mutex is owned by the first process. The named 
// mutex is destroyed when all the Mutex objects that represent it
// have been released. 
// The second process (and any subsequent process) waits for earlier
// processes to release the named mutex.

using System;
using System.Threading;

public class Test12
{
    public static void Main()
    {
        // Set this variable to false if you do not want to request 
        // initial ownership of the named mutex.
        bool requestInitialOwnership = true;
        bool mutexWasCreated;

        // Request initial ownership of the named mutex by passing
        // true for the first parameter. Only one system object named 
        // "MyMutex" can exist; the local Mutex object represents 
        // this system object. If "MyMutex" is created by this call,
        // then mutexWasCreated contains true; otherwise, it contains
        // false.
        Mutex m = new Mutex(requestInitialOwnership, 
                            "MyMutex", 
                            out mutexWasCreated);
        
        // This thread owns the mutex only if it both requested 
        // initial ownership and created the named mutex. Otherwise,
        // it can request the named mutex by calling WaitOne.
        if (!(requestInitialOwnership && mutexWasCreated))
        {
            Console.WriteLine("Waiting for the named mutex.");
            m.WaitOne();
        }

        // Once the process has gained control of the named mutex,
        // hold onto it until the user presses ENTER.
        Console.WriteLine("This process owns the named mutex. " +
            "Press ENTER to release the mutex and exit.");
        Console.ReadLine();

        // Call ReleaseMutex to allow other threads to gain control
        // of the named mutex. If you keep a reference to the local
        // Mutex, you can call WaitOne to request control of the 
        // named mutex.
        m.ReleaseMutex();
    }
}
' This example shows how a named mutex is used to signal between
' processes or threads.
' Run this program from two (or more) command windows. Each process
' creates a Mutex object that represents the named mutex "MyMutex".
' The named mutex is a system object whose lifetime is bounded by the
' lifetimes of the Mutex objects that represent it. The named mutex
' is created when the first process creates its local Mutex; in this
' example, the named mutex is owned by the first process. The named 
' mutex is destroyed when all the Mutex objects that represent it
' have been released. 
' The second process (and any subsequent process) waits for earlier
' processes to release the named mutex.

Imports System.Threading

Public Class Test
   
   <MTAThread> _
   Public Shared Sub Main()
      ' Set this variable to false if you do not want to request 
      ' initial ownership of the named mutex.
      Dim requestInitialOwnership As Boolean = True
      Dim mutexWasCreated As Boolean
      
      ' Request initial ownership of the named mutex by passing
      ' true for the first parameter. Only one system object named 
      ' "MyMutex" can exist; the local Mutex object represents 
      ' this system object. If "MyMutex" is created by this call,
      ' then mutexWasCreated contains true; otherwise, it contains
      ' false.
      Dim m As New Mutex(requestInitialOwnership, "MyMutex", _
          mutexWasCreated)
      
      ' This thread owns the mutex only if it both requested 
      ' initial ownership and created the named mutex. Otherwise,
      ' it can request the named mutex by calling WaitOne.
      If Not (requestInitialOwnership And mutexWasCreated) Then
         Console.WriteLine("Waiting for the named mutex.")
         m.WaitOne()
      End If
      
      ' Once the process has gained control of the named mutex,
      ' hold onto it until the user presses ENTER.
      Console.WriteLine("This process owns the named mutex. " _
          & "Press ENTER to release the mutex and exit.")
      Console.ReadLine()
      
      ' Call ReleaseMutex to allow other threads to gain control
      ' of the named mutex. If you keep a reference to the local
      ' Mutex, you can call WaitOne to request control of the 
      ' named mutex.
      m.ReleaseMutex()
   End Sub
End Class

Hinweise

Der name kann mit Global\ dem Präfix oder Local\ versehen sein, um einen Namespace anzugeben. Wenn der Global Namespace angegeben wird, kann das Synchronisierungsobjekt für alle Prozesse im System freigegeben werden. Wenn der Local Namespace angegeben ist, was auch der Standardwert ist, wenn kein Namespace angegeben wird, kann das Synchronisierungsobjekt für Prozesse in derselben Sitzung freigegeben werden. Unter Windows ist eine Sitzung eine Anmeldesitzung, und Dienste werden in der Regel in einer anderen nicht interaktiven Sitzung ausgeführt. Unter Unix-ähnlichen Betriebssystemen verfügt jede Shell über eine eigene Sitzung. Sitzungslokale Synchronisierungsobjekte eignen sich möglicherweise für die Synchronisierung zwischen Prozessen mit einer übergeordneten/untergeordneten Beziehung, bei der sie alle in derselben Sitzung ausgeführt werden. Weitere Informationen zu Synchronisierungsobjektnamen unter Windows finden Sie unter Objektnamen.

Wenn ein name bereitgestellt wird und bereits ein Synchronisierungsobjekt des angeforderten Typs im Namespace vorhanden ist, wird das vorhandene Synchronisierungsobjekt verwendet. Wenn im Namespace bereits ein Synchronisierungsobjekt eines anderen Typs vorhanden ist, wird ein WaitHandleCannotBeOpenedException ausgelöst. Andernfalls wird ein neues Synchronisierungsobjekt erstellt.

Wenn name nicht null und initiallyOwned ist, besitzt trueder aufrufende Thread den benannten Mutex nur, wenn createdNew sich nach dem Aufruf befindet true . Andernfalls kann der Thread den Mutex anfordern, indem die WaitOne -Methode aufgerufen wird.

Dieser Konstruktor initialisiert ein Mutex Objekt, das einen benannten Systemmutex darstellt. Sie können mehrere Mutex Objekte erstellen, die denselben benannten Systemmutex darstellen.

Wenn der benannte Mutex bereits mit Zugriffssteuerungssicherheit erstellt wurde und der Aufrufer keine Rechte besitzt MutexRights.FullControl , wird eine Ausnahme ausgelöst. Informationen zum Öffnen eines vorhandenen benannten Mutex mit nur den Berechtigungen, die für die Synchronisierung von Threadaktivitäten erforderlich sind, finden Sie in der OpenExisting -Methode.

Wenn Sie eine leere Zeichenfolge für nameangebennull, wird ein lokaler Mutex erstellt, als hätten Sie den Mutex(Boolean) Konstruktor aufgerufen. In diesem Fall createdNew ist immer true.

Da sie systemweit sind, können benannte Mutexes verwendet werden, um die Ressourcennutzung über Prozessgrenzen hinweg zu koordinieren.

Hinweis

Auf einem Server, auf dem Terminaldienste ausgeführt werden, kann ein benannter Systemmutex zwei Sichtbarkeitsebenen aufweisen. Wenn sein Name mit dem Präfix Global\beginnt, ist der Mutex in allen Terminalserversitzungen sichtbar. Wenn sein Name mit dem Präfix Local\beginnt, ist der Mutex nur in der Terminalserversitzung sichtbar, in der er erstellt wurde. In diesem Fall kann in jeder der anderen Terminalserversitzungen auf dem Server ein separater Mutex mit demselben Namen vorhanden sein. Wenn Sie beim Erstellen eines benannten Mutex kein Präfix angeben, wird das Präfix Local\verwendet. Innerhalb einer Terminalserversitzung sind zwei Mutexe, deren Namen sich nur durch ihre Präfixe unterscheiden, separate Mutexe, und beide sind für alle Prozesse in der Terminalserversitzung sichtbar. Das heißt, die Präfixnamen Global\ und Local\ beschreiben den Bereich des Mutexnamens relativ zu Terminalserversitzungen, nicht relativ zu Prozessen.

Achtung

Standardmäßig ist ein benannter Mutex nicht auf den Benutzer beschränkt, der ihn erstellt hat. Andere Benutzer können den Mutex möglicherweise öffnen und verwenden, einschließlich der Störung des Mutex, indem sie den Mutex eingeben und ihn nicht verlassen. Unter Unix-ähnlichen Betriebssystemen wird das Dateisystem bei der Implementierung von benannten Mutexes verwendet, und andere Benutzer können in der Lage sein, benannte Mutexes auf größere Weise zu beeinträchtigen. Wenn Sie unter Windows den Zugriff auf bestimmte Benutzer einschränken möchten, können Sie eine Konstruktorüberladung oder MutexAcl einen MutexSecurity verwenden und beim Erstellen des benannten Mutex übergeben. Unter Unix-ähnlichen Betriebssystemen gibt es derzeit keine Möglichkeit, den Zugriff auf einen benannten Mutex einzuschränken. Vermeiden Sie die Verwendung benannter Mutexes ohne Zugriffsbeschränkungen auf Systemen, auf denen möglicherweise nicht vertrauenswürdige Benutzer Code ausführen.

Der umgekehrte Schrägstrich (\) ist ein reserviertes Zeichen in einem Mutex-Namen. Verwenden Sie keinen umgekehrten Schrägstrich (\) in einem Mutex-Namen, außer wie im Hinweis zur Verwendung von Mutexes in Terminalserversitzungen angegeben. Andernfalls kann sogar eine DirectoryNotFoundException ausgelöst werden, wenn der Mutex-Name für eine bereits vorhandene Datei steht.

Weitere Informationen

Gilt für:

Mutex(Boolean, String, Boolean, MutexSecurity)

Initialisiert eine neue Instanz der Mutex-Klasse mit einem booleschen Wert, der angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex zugewiesen werden soll, mit einer Zeichenfolge mit dem Namen des Mutex, mit einer booleschen Variable, die beim Beenden der Methode angibt, ob dem aufrufenden Thread der anfängliche Besitz des Mutex gewährt wurde, und mit der Zugriffssteuerungssicherheit, die auf den benannten Mutex angewendet werden soll.

public:
 Mutex(bool initiallyOwned, System::String ^ name, [Runtime::InteropServices::Out] bool % createdNew, System::Security::AccessControl::MutexSecurity ^ mutexSecurity);
public Mutex (bool initiallyOwned, string name, out bool createdNew, System.Security.AccessControl.MutexSecurity mutexSecurity);
[System.Security.SecurityCritical]
public Mutex (bool initiallyOwned, string name, out bool createdNew, System.Security.AccessControl.MutexSecurity mutexSecurity);
new System.Threading.Mutex : bool * string * bool * System.Security.AccessControl.MutexSecurity -> System.Threading.Mutex
[<System.Security.SecurityCritical>]
new System.Threading.Mutex : bool * string * bool * System.Security.AccessControl.MutexSecurity -> System.Threading.Mutex
Public Sub New (initiallyOwned As Boolean, name As String, ByRef createdNew As Boolean, mutexSecurity As MutexSecurity)

Parameter

initiallyOwned
Boolean

true, um dem aufrufenden Thread den anfänglichen Besitz des benannten Systemmutex zuzuweisen, wenn der benannte Systemmutex als Ergebnis dieses Aufrufs erstellt wird, andernfalls false.

name
String

Der Name, wenn das Synchronisierungsobjekt für andere Prozesse freigegeben werden soll; andernfalls null oder eine leere Zeichenfolge. Bei dem Namen wird die Groß- und Kleinschreibung berücksichtigt. Der umgekehrte Schrägstrich (\) ist reserviert und kann nur zum Angeben eines Namespace verwendet werden. Weitere Informationen zu Namespaces finden Sie im Abschnitt Hinweise. Je nach Betriebssystem kann es weitere Einschränkungen für den Namen geben. Unter Unix-basierten Betriebssystemen muss der Name nach dem Ausschluss des Namespace beispielsweise ein gültiger Dateiname sein.

createdNew
Boolean

Enthält nach dem Beenden dieser Methode einen booleschen Wert, der true ist, wenn ein lokaler Mutex erstellt wurde (d. h. wenn name gleich null oder eine leere Zeichenfolge ist) oder wenn der angegebene benannte Systemmutex erstellt wurde. Der Wert ist false, wenn der angegebene benannte Systemmutex bereits vorhanden war. Dieser Parameter wird nicht initialisiert übergeben.

mutexSecurity
MutexSecurity

Ein MutexSecurity-Objekt, das die Zugriffssteuerungssicherheit darstellt, die auf den benannten Systemmutex angewendet werden soll.

Attribute

Ausnahmen

name ist ungültig. Dies kann aus verschiedenen Gründen der Fall sein, z. B. durch Einschränkungen, die vom Betriebssystem auferlegt werden, etwa ein unbekanntes Präfix oder ungültige Zeichen. Beachten Sie, dass bei dem Namen und den gängigen Präfixen "Global\" und "Local\" die Groß-/Kleinschreibung beachtet wird.

- oder -

Es ist ein anderer Fehler aufgetreten. DieHResult-Eigenschaft stellt möglicherweise weitere Informationen zur Verfügung.

Nur Windows: name hat einen unbekannten Namespace angegeben. Weitere Informationen finden Sie unter Objektnamen.

name ist zu lang. Längeneinschränkungen können vom Betriebssystem oder der Konfiguration abhängen.

Das benannte Mutex ist vorhanden und verfügt über Zugriffssteuerungssicherheit, aber der Benutzer verfügt nicht über FullControl.

Ein Synchronisierungsobjekt mit dem angegebenen name kann nicht erstellt werden. Ein Synchronisierungsobjekt eines anderen Typs weist ggf. denselben Namen auf.

Nur .NET Framework: name ist länger als MAX_PATH (260 Zeichen).

Beispiele

Im folgenden Codebeispiel wird das prozessübergreifende Verhalten eines benannten Mutex mit Zugriffssteuerungssicherheit veranschaulicht. Im Beispiel wird die OpenExisting(String) Methodenüberladung verwendet, um das Vorhandensein eines benannten Mutex zu testen.

Wenn der Mutex nicht vorhanden ist, wird er mit der anfänglichen Besitz- und Zugriffssteuerungssicherheit erstellt, die dem aktuellen Benutzer das Recht zur Verwendung des Mutex verweigert, aber das Recht zum Lesen und Ändern von Berechtigungen für den Mutex gewährt.

Wenn Sie das kompilierte Beispiel über zwei Befehlsfenster ausführen, löst die zweite Kopie eine Zugriffsverletzungs-Ausnahme für den Aufruf von aus OpenExisting(String). Die Ausnahme wird abgefangen, und das Beispiel verwendet die OpenExisting(String, MutexRights) Methodenüberladung, um den Mutex mit den Rechten zu öffnen, die zum Lesen und Ändern der Berechtigungen erforderlich sind.

Nachdem die Berechtigungen geändert wurden, wird der Mutex mit den zum Eingeben und Freigeben erforderlichen Rechten geöffnet. Wenn Sie das kompilierte Beispiel über ein drittes Befehlsfenster ausführen, wird es mit den neuen Berechtigungen ausgeführt.

using namespace System;
using namespace System::Threading;
using namespace System::Security::AccessControl;
using namespace System::Security::Permissions;

public ref class Example
{
public:
   [SecurityPermissionAttribute(SecurityAction::Demand,Flags=SecurityPermissionFlag::UnmanagedCode)]
   static void Main()
   {
      String^ mutexName = L"MutexExample4";

      Mutex^ m = nullptr;
      bool doesNotExist = false;
      bool unauthorized = false;
      
      // The value of this variable is set by the mutex
      // constructor. It is true if the named system mutex was
      // created, and false if the named mutex already existed.
      //
      bool mutexWasCreated = false;

      // Attempt to open the named mutex.
      try
      {
         // Open the mutex with (MutexRights.Synchronize |
         // MutexRights.Modify), to enter and release the
         // named mutex.
         //
         m = Mutex::OpenExisting( mutexName );
      }
      catch ( WaitHandleCannotBeOpenedException^ ) 
      {
         Console::WriteLine( L"Mutex does not exist." );
         doesNotExist = true;
      }
      catch ( UnauthorizedAccessException^ ex ) 
      {
         Console::WriteLine( L"Unauthorized access: {0}", ex->Message );
         unauthorized = true;
      }

      // There are three cases: (1) The mutex does not exist.
      // (2) The mutex exists, but the current user doesn't
      // have access. (3) The mutex exists and the user has
      // access.
      //
      if ( doesNotExist )
      {
         // The mutex does not exist, so create it.
         // Create an access control list (ACL) that denies the
         // current user the right to enter or release the
         // mutex, but allows the right to read and change
         // security information for the mutex.
         //
         String^ user = String::Concat( Environment::UserDomainName, L"\\",
            Environment::UserName );
         MutexSecurity^ mSec = gcnew MutexSecurity;

         MutexAccessRule^ rule = gcnew MutexAccessRule( user,
            static_cast<MutexRights>(
               MutexRights::Synchronize |
               MutexRights::Modify),
            AccessControlType::Deny );
         mSec->AddAccessRule( rule );

         rule = gcnew MutexAccessRule( user,
            static_cast<MutexRights>(
               MutexRights::ReadPermissions |
                MutexRights::ChangePermissions),
            AccessControlType::Allow );
         mSec->AddAccessRule( rule );
         
         // Create a Mutex object that represents the system
         // mutex named by the constant 'mutexName', with
         // initial ownership for this thread, and with the
         // specified security access. The Boolean value that
         // indicates creation of the underlying system object
         // is placed in mutexWasCreated.
         //
         m = gcnew Mutex( true,mutexName, mutexWasCreated,mSec );
         
         // If the named system mutex was created, it can be
         // used by the current instance of this program, even
         // though the current user is denied access. The current
         // program owns the mutex. Otherwise, exit the program.
         //
         if ( mutexWasCreated )
         {
            Console::WriteLine( L"Created the mutex." );
         }
         else
         {
            Console::WriteLine( L"Unable to create the mutex." );
            return;
         }
      }
      else if ( unauthorized )
      {
         // Open the mutex to read and change the access control
         // security. The access control security defined above
         // allows the current user to do this.
         //
         try
         {
            m = Mutex::OpenExisting( mutexName,
               static_cast<MutexRights>(
                  MutexRights::ReadPermissions |
                  MutexRights::ChangePermissions) );
            
            // Get the current ACL. This requires
            // MutexRights.ReadPermissions.
            MutexSecurity^ mSec = m->GetAccessControl();

            String^ user = String::Concat( Environment::UserDomainName,
               L"\\", Environment::UserName );
            
            // First, the rule that denied the current user
            // the right to enter and release the mutex must
            // be removed.
            MutexAccessRule^ rule = gcnew MutexAccessRule( user,
               static_cast<MutexRights>(
                  MutexRights::Synchronize |
                  MutexRights::Modify),
               AccessControlType::Deny );
            mSec->RemoveAccessRule( rule );
            
            // Now grant the user the correct rights.
            //
            rule = gcnew MutexAccessRule( user,
               static_cast<MutexRights>(
                  MutexRights::Synchronize |
                  MutexRights::Modify),
               AccessControlType::Allow );
            mSec->AddAccessRule( rule );
            
            // Update the ACL. This requires
            // MutexRights.ChangePermissions.
            m->SetAccessControl( mSec );

            Console::WriteLine( L"Updated mutex security." );
            
            // Open the mutex with (MutexRights.Synchronize
            // | MutexRights.Modify), the rights required to
            // enter and release the mutex.
            //
            m = Mutex::OpenExisting( mutexName );
         }
         catch ( UnauthorizedAccessException^ ex ) 
         {
            Console::WriteLine(
               L"Unable to change permissions: {0}", ex->Message );
            return;
         }
      }
      
      // If this program created the mutex, it already owns
      // the mutex.
      //
      if ( !mutexWasCreated )
      {
         // Enter the mutex, and hold it until the program
         // exits.
         //
         try
         {
            Console::WriteLine( L"Wait for the mutex." );
            m->WaitOne();
            Console::WriteLine( L"Entered the mutex." );
         }
         catch ( UnauthorizedAccessException^ ex ) 
         {
            Console::WriteLine( L"Unauthorized access: {0}",
               ex->Message );
         }
      }

      Console::WriteLine( L"Press the Enter key to exit." );
      Console::ReadLine();
      m->ReleaseMutex();
      m->Dispose();
   }
};

int main()
{
   Example::Main();
}
using System;
using System.Threading;
using System.Security.AccessControl;

internal class Example
{
    internal static void Main()
    {
        const string mutexName = "MutexExample4";

        Mutex m = null;
        bool doesNotExist = false;
        bool unauthorized = false;

        // The value of this variable is set by the mutex
        // constructor. It is true if the named system mutex was
        // created, and false if the named mutex already existed.
        //
        bool mutexWasCreated = false;

        // Attempt to open the named mutex.
        try
        {
            // Open the mutex with (MutexRights.Synchronize |
            // MutexRights.Modify), to enter and release the
            // named mutex.
            //
            m = Mutex.OpenExisting(mutexName);
        }
        catch(WaitHandleCannotBeOpenedException)
        {
            Console.WriteLine("Mutex does not exist.");
            doesNotExist = true;
        }
        catch(UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
            unauthorized = true;
        }

        // There are three cases: (1) The mutex does not exist.
        // (2) The mutex exists, but the current user doesn't 
        // have access. (3) The mutex exists and the user has
        // access.
        //
        if (doesNotExist)
        {
            // The mutex does not exist, so create it.

            // Create an access control list (ACL) that denies the
            // current user the right to enter or release the 
            // mutex, but allows the right to read and change
            // security information for the mutex.
            //
            string user = Environment.UserDomainName + "\\"
                + Environment.UserName;
            var mSec = new MutexSecurity();

            MutexAccessRule rule = new MutexAccessRule(user, 
                MutexRights.Synchronize | MutexRights.Modify, 
                AccessControlType.Deny);
            mSec.AddAccessRule(rule);

            rule = new MutexAccessRule(user, 
                MutexRights.ReadPermissions | MutexRights.ChangePermissions,
                AccessControlType.Allow);
            mSec.AddAccessRule(rule);

            // Create a Mutex object that represents the system
            // mutex named by the constant 'mutexName', with
            // initial ownership for this thread, and with the
            // specified security access. The Boolean value that 
            // indicates creation of the underlying system object
            // is placed in mutexWasCreated.
            //
            m = new Mutex(true, mutexName, out mutexWasCreated, mSec);

            // If the named system mutex was created, it can be
            // used by the current instance of this program, even 
            // though the current user is denied access. The current
            // program owns the mutex. Otherwise, exit the program.
            // 
            if (mutexWasCreated)
            {
                Console.WriteLine("Created the mutex.");
            }
            else
            {
                Console.WriteLine("Unable to create the mutex.");
                return;
            }
        }
        else if (unauthorized)
        {
            // Open the mutex to read and change the access control
            // security. The access control security defined above
            // allows the current user to do this.
            //
            try
            {
                m = Mutex.OpenExisting(mutexName, 
                    MutexRights.ReadPermissions | MutexRights.ChangePermissions);

                // Get the current ACL. This requires 
                // MutexRights.ReadPermissions.
                MutexSecurity mSec = m.GetAccessControl();
                
                string user = Environment.UserDomainName + "\\"
                    + Environment.UserName;

                // First, the rule that denied the current user 
                // the right to enter and release the mutex must
                // be removed.
                MutexAccessRule rule = new MutexAccessRule(user, 
                     MutexRights.Synchronize | MutexRights.Modify,
                     AccessControlType.Deny);
                mSec.RemoveAccessRule(rule);

                // Now grant the user the correct rights.
                // 
                rule = new MutexAccessRule(user, 
                    MutexRights.Synchronize | MutexRights.Modify,
                    AccessControlType.Allow);
                mSec.AddAccessRule(rule);

                // Update the ACL. This requires
                // MutexRights.ChangePermissions.
                m.SetAccessControl(mSec);

                Console.WriteLine("Updated mutex security.");

                // Open the mutex with (MutexRights.Synchronize 
                // | MutexRights.Modify), the rights required to
                // enter and release the mutex.
                //
                m = Mutex.OpenExisting(mutexName);
            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unable to change permissions: {0}",
                    ex.Message);
                return;
            }
        }

        // If this program created the mutex, it already owns
        // the mutex.
        //
        if (!mutexWasCreated)
        {
            // Enter the mutex, and hold it until the program
            // exits.
            //
            try
            {
                Console.WriteLine("Wait for the mutex.");
                m.WaitOne();
                Console.WriteLine("Entered the mutex.");
            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unauthorized access: {0}", ex.Message);
            }
        }

        Console.WriteLine("Press the Enter key to exit.");
        Console.ReadLine();
        m.ReleaseMutex();
        m.Dispose();
    }
}
Imports System.Threading
Imports System.Security.AccessControl

Friend Class Example

    <MTAThread> _
    Friend Shared Sub Main()
        Const mutexName As String = "MutexExample4"

        Dim m As Mutex = Nothing
        Dim doesNotExist as Boolean = False
        Dim unauthorized As Boolean = False

        ' The value of this variable is set by the mutex
        ' constructor. It is True if the named system mutex was
        ' created, and False if the named mutex already existed.
        '
        Dim mutexWasCreated As Boolean

        ' Attempt to open the named mutex.
        Try
            ' Open the mutex with (MutexRights.Synchronize Or
            ' MutexRights.Modify), to enter and release the
            ' named mutex.
            '
            m = Mutex.OpenExisting(mutexName)
        Catch ex As WaitHandleCannotBeOpenedException
            Console.WriteLine("Mutex does not exist.")
            doesNotExist = True
        Catch ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", ex.Message)
            unauthorized = True
        End Try

        ' There are three cases: (1) The mutex does not exist.
        ' (2) The mutex exists, but the current user doesn't 
        ' have access. (3) The mutex exists and the user has
        ' access.
        '
        If doesNotExist Then
            ' The mutex does not exist, so create it.

            ' Create an access control list (ACL) that denies the
            ' current user the right to enter or release the 
            ' mutex, but allows the right to read and change
            ' security information for the mutex.
            '
            Dim user As String = Environment.UserDomainName _ 
                & "\" & Environment.UserName
            Dim mSec As New MutexSecurity()

            Dim rule As New MutexAccessRule(user, _
                MutexRights.Synchronize Or MutexRights.Modify, _
                AccessControlType.Deny)
            mSec.AddAccessRule(rule)

            rule = New MutexAccessRule(user, _
                MutexRights.ReadPermissions Or _
                MutexRights.ChangePermissions, _
                AccessControlType.Allow)
            mSec.AddAccessRule(rule)

            ' Create a Mutex object that represents the system
            ' mutex named by the constant 'mutexName', with
            ' initial ownership for this thread, and with the
            ' specified security access. The Boolean value that 
            ' indicates creation of the underlying system object
            ' is placed in mutexWasCreated.
            '
            m = New Mutex(True, mutexName, mutexWasCreated, mSec)

            ' If the named system mutex was created, it can be
            ' used by the current instance of this program, even 
            ' though the current user is denied access. The current
            ' program owns the mutex. Otherwise, exit the program.
            ' 
            If mutexWasCreated Then
                Console.WriteLine("Created the mutex.")
            Else
                Console.WriteLine("Unable to create the mutex.")
                Return
            End If

        ElseIf unauthorized Then

            ' Open the mutex to read and change the access control
            ' security. The access control security defined above
            ' allows the current user to do this.
            '
            Try
                m = Mutex.OpenExisting(mutexName, _
                    MutexRights.ReadPermissions Or _
                    MutexRights.ChangePermissions)

                ' Get the current ACL. This requires 
                ' MutexRights.ReadPermissions.
                Dim mSec As MutexSecurity = m.GetAccessControl()
                
                Dim user As String = Environment.UserDomainName _ 
                    & "\" & Environment.UserName

                ' First, the rule that denied the current user 
                ' the right to enter and release the mutex must
                ' be removed.
                Dim rule As New MutexAccessRule(user, _
                    MutexRights.Synchronize Or MutexRights.Modify, _
                    AccessControlType.Deny)
                mSec.RemoveAccessRule(rule)

                ' Now grant the user the correct rights.
                ' 
                rule = New MutexAccessRule(user, _
                    MutexRights.Synchronize Or MutexRights.Modify, _
                    AccessControlType.Allow)
                mSec.AddAccessRule(rule)

                ' Update the ACL. This requires
                ' MutexRights.ChangePermissions.
                m.SetAccessControl(mSec)

                Console.WriteLine("Updated mutex security.")

                ' Open the mutex with (MutexRights.Synchronize 
                ' Or MutexRights.Modify), the rights required to
                ' enter and release the mutex.
                '
                m = Mutex.OpenExisting(mutexName)

            Catch ex As UnauthorizedAccessException
                Console.WriteLine("Unable to change permissions: {0}", _
                    ex.Message)
                Return
            End Try

        End If

        ' If this program created the mutex, it already owns
        ' the mutex.
        '
        If Not mutexWasCreated Then
            ' Enter the mutex, and hold it until the program
            ' exits.
            '
            Try
                Console.WriteLine("Wait for the mutex.")
                m.WaitOne()
                Console.WriteLine("Entered the mutex.")
            Catch ex As UnauthorizedAccessException
                Console.WriteLine("Unauthorized access: {0}", _
                    ex.Message)
            End Try
        End If

        Console.WriteLine("Press the Enter key to exit.")
        Console.ReadLine()
        m.ReleaseMutex()
        m.Dispose()
    End Sub 
End Class

Hinweise

Der name kann mit Global\ dem Präfix oder Local\ versehen sein, um einen Namespace anzugeben. Wenn der Global Namespace angegeben wird, kann das Synchronisierungsobjekt für alle Prozesse im System freigegeben werden. Wenn der Local Namespace angegeben ist, was auch der Standardwert ist, wenn kein Namespace angegeben wird, kann das Synchronisierungsobjekt für Prozesse in derselben Sitzung freigegeben werden. Unter Windows ist eine Sitzung eine Anmeldesitzung, und Dienste werden in der Regel in einer anderen nicht interaktiven Sitzung ausgeführt. Unter Unix-ähnlichen Betriebssystemen verfügt jede Shell über eine eigene Sitzung. Sitzungslokale Synchronisierungsobjekte eignen sich möglicherweise für die Synchronisierung zwischen Prozessen mit einer übergeordneten/untergeordneten Beziehung, bei der sie alle in derselben Sitzung ausgeführt werden. Weitere Informationen zu Synchronisierungsobjektnamen unter Windows finden Sie unter Objektnamen.

Wenn ein name bereitgestellt wird und bereits ein Synchronisierungsobjekt des angeforderten Typs im Namespace vorhanden ist, wird das vorhandene Synchronisierungsobjekt verwendet. Wenn im Namespace bereits ein Synchronisierungsobjekt eines anderen Typs vorhanden ist, wird ein WaitHandleCannotBeOpenedException ausgelöst. Andernfalls wird ein neues Synchronisierungsobjekt erstellt.

Wenn name nicht null und initiallyOwned ist, besitzt trueder aufrufende Thread den benannten Mutex nur, wenn createdNew sich nach dem Aufruf befindet true . Andernfalls kann der Thread den Mutex anfordern, indem die WaitOne -Methode aufgerufen wird.

Verwenden Sie diesen Konstruktor, um die Zugriffssteuerungssicherheit auf einen benannten Systemmutex anzuwenden, wenn er erstellt wird, um zu verhindern, dass anderer Code die Kontrolle über den Mutex übernimmt.

Dieser Konstruktor initialisiert ein Mutex Objekt, das einen benannten Systemmutex darstellt. Sie können mehrere Mutex Objekte erstellen, die denselben benannten Systemmutex darstellen.

Wenn der benannte Systemmutex nicht vorhanden ist, wird er mit der angegebenen Zugriffssteuerungssicherheit erstellt. Wenn der benannte Mutex vorhanden ist, wird die angegebene Zugriffssteuerungssicherheit ignoriert.

Hinweis

Der Aufrufer hat die volle Kontrolle über das neu erstellte Mutex Objekt, auch wenn mutexSecurity dem aktuellen Benutzer einige Zugriffsrechte verweigert oder nicht erteilt werden. Wenn der aktuelle Benutzer jedoch versucht, ein anderes Mutex Objekt abzurufen, das denselben Namen mutex darstellt, indem er entweder einen Konstruktor oder die -Methode verwendet, wird die OpenExisting Windows-Zugriffssteuerungssicherheit angewendet.

Wenn der benannte Mutex bereits mit Zugriffssteuerungssicherheit erstellt wurde und der Aufrufer nicht verfügt MutexRights.FullControl, wird eine Ausnahme ausgelöst. Informationen zum Öffnen eines vorhandenen benannten Mutex mit nur den Berechtigungen, die für die Synchronisierung von Threadaktivitäten erforderlich sind, finden Sie in der OpenExisting -Methode.

Wenn Sie eine leere Zeichenfolge für nameangebennull, wird ein lokaler Mutex erstellt, als hätten Sie den Mutex(Boolean) Konstruktor aufgerufen. In diesem Fall createdNew ist immer true.

Da sie systemweit sind, können benannte Mutexes verwendet werden, um die Ressourcennutzung über Prozessgrenzen hinweg zu koordinieren.

Hinweis

Auf einem Server, auf dem Terminaldienste ausgeführt werden, kann ein benannter Systemmutex zwei Sichtbarkeitsebenen aufweisen. Wenn sein Name mit dem Präfix Global\beginnt, ist der Mutex in allen Terminalserversitzungen sichtbar. Wenn sein Name mit dem Präfix Local\beginnt, ist der Mutex nur in der Terminalserversitzung sichtbar, in der er erstellt wurde. In diesem Fall kann in jeder der anderen Terminalserversitzungen auf dem Server ein separater Mutex mit demselben Namen vorhanden sein. Wenn Sie beim Erstellen eines benannten Mutex kein Präfix angeben, wird das Präfix Local\verwendet. Innerhalb einer Terminalserversitzung sind zwei Mutexe, deren Namen sich nur durch ihre Präfixe unterscheiden, separate Mutexe, und beide sind für alle Prozesse in der Terminalserversitzung sichtbar. Das heißt, die Präfixnamen Global\ und Local\ beschreiben den Bereich des Mutexnamens relativ zu Terminalserversitzungen, nicht relativ zu Prozessen.

Achtung

Standardmäßig ist ein benannter Mutex nicht auf den Benutzer beschränkt, der ihn erstellt hat. Andere Benutzer können den Mutex möglicherweise öffnen und verwenden, einschließlich der Störung des Mutex, indem sie den Mutex eingeben und ihn nicht verlassen. Um den Zugriff auf bestimmte Benutzer einzuschränken, können Sie beim Erstellen des benannten Mutex einen MutexSecurity übergeben. Vermeiden Sie die Verwendung benannter Mutexes ohne Zugriffsbeschränkungen auf Systemen, auf denen möglicherweise nicht vertrauenswürdige Benutzer Code ausführen.

Der umgekehrte Schrägstrich (\) ist ein reserviertes Zeichen in einem Mutex-Namen. Verwenden Sie keinen umgekehrten Schrägstrich (\) in einem Mutex-Namen, außer wie im Hinweis zur Verwendung von Mutexes in Terminalserversitzungen angegeben. Andernfalls kann sogar eine DirectoryNotFoundException ausgelöst werden, wenn der Mutex-Name für eine bereits vorhandene Datei steht.

Gilt für: