Mutex Constructors

public:
 Mutex();

public Mutex();

Public Sub New ()

Voorbeelden

In het volgende codevoorbeeld ziet u hoe een lokaal Mutex object wordt gebruikt om de toegang tot een beveiligde resource te synchroniseren. De thread waarmee de mutex wordt gemaakt, is in eerste instantie niet de eigenaar.

// 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

Opmerkingen

Het aanroepen van deze constructoroverbelasting is hetzelfde als het aanroepen van de overbelasting van de Mutex(Boolean) constructor en het opgeven false van het eerste eigendom van de mutex. Dat wil zeggen dat de aanroepende thread geen eigenaar is van de mutex.

Zie ook

• Het Beheerd Draadbeheer
• Mutexes-

public:
 Mutex(bool initiallyOwned);

public Mutex(bool initiallyOwned);

new System.Threading.Mutex : bool -> System.Threading.Mutex

Public Sub New (initiallyOwned As Boolean)

Parameters

Voorbeelden

In het volgende codevoorbeeld ziet u hoe een lokaal Mutex object wordt gebruikt om de toegang tot een beveiligde resource te synchroniseren. De thread waarmee de Mutex eigenaar wordt gemaakt, wordt in eerste instantie gemaakt.

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

Zie ook

• Het Beheerd Draadbeheer
• Mutexes-

public:
 Mutex(bool initiallyOwned, System::String ^ name);

[System.Security.SecurityCritical]
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)

Parameters

Kenmerken

SecurityCriticalAttribute

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u hoe een benoemde mutex wordt gebruikt om te signaleren tussen threads die in twee afzonderlijke processen worden uitgevoerd.

Voer dit programma uit vanuit twee of meer opdrachtvensters. Elk proces maakt een Mutex object dat de benoemde mutex MyMutexvertegenwoordigt. De benoemde mutex is een systeemobject waarvan de levensduur afhankelijk is van de levensduur van de Mutex objecten die het vertegenwoordigen. De benoemde mutex wordt gemaakt wanneer het eerste proces het Mutex object maakt. In dit voorbeeld is de benoemde mutex eigendom van het eerste proces dat het programma uitvoert. De benoemde mutex wordt vernietigd wanneer alle Mutex objecten die het vertegenwoordigen, zijn vrijgegeven.

De overbelasting van de constructor die in dit voorbeeld wordt gebruikt, kan de aanroepende thread niet vertellen of het oorspronkelijke eigendom van de benoemde mutex is verleend. Gebruik deze constructor niet om initiële eigendom aan te vragen, tenzij u zeker weet dat de thread de benoemde mutex maakt.

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

Opmerkingen

De name naamruimte kan worden voorafgegaan door Global\ of Local\ om een naamruimte op te geven. Wanneer de Global naamruimte is opgegeven, kan het synchronisatieobject worden gedeeld met processen op het systeem. Wanneer de Local naamruimte is opgegeven, wat ook de standaardwaarde is wanneer er geen naamruimte is opgegeven, kan het synchronisatieobject worden gedeeld met processen in dezelfde sessie. Op Windows is een sessie een aanmeldingssessie en worden services meestal uitgevoerd in een andere niet-interactieve sessie. Op Unix-achtige besturingssystemen heeft elke shell een eigen sessie. Sessie-lokale synchronisatieobjecten zijn mogelijk geschikt voor synchronisatie tussen processen met een bovenliggende/onderliggende relatie, waar ze allemaal in dezelfde sessie worden uitgevoerd. Zie Objectnamen voor meer informatie over de namen van synchronisatieobjecten in Windows.

Als er een name is opgegeven en er al een synchronisatieobject van het aangevraagde type bestaat in de naamruimte, wordt het bestaande synchronisatieobject gebruikt. Als er al een synchronisatieobject van een ander type bestaat in de naamruimte, wordt er een WaitHandleCannotBeOpenedException gegenereerd. Anders wordt er een nieuw synchronisatieobject gemaakt.

Als name dat niet null het is en initiallyOwned is true, is de aanroepende thread alleen eigenaar van de mutex als de benoemde systeemmutex is gemaakt als gevolg van deze aanroep. Omdat er geen mechanisme is om te bepalen of de benoemde systeemmutex is gemaakt, is het beter om op te geven false voor initiallyOwned het aanroepen van deze constructoroverbelasting. U kunt de Mutex(Boolean, String, Boolean) constructor gebruiken als u het oorspronkelijke eigendom wilt bepalen.

Met deze constructor wordt een Mutex object geïnitialiseerd dat een benoemde systeemmutex vertegenwoordigt. U kunt meerdere Mutex objecten maken die dezelfde benoemde systeemmutex vertegenwoordigen.

Als de benoemde mutex al is gemaakt met toegangsbeheerbeveiliging en de beller niet beschikt MutexRights.FullControl, wordt er een uitzondering gegenereerd. Als u een bestaande benoemde mutex wilt openen met alleen de machtigingen die nodig zijn voor het synchroniseren van threadactiviteiten, raadpleegt u de OpenExisting methode.

Als u opgeeft null of een lege tekenreeks voor name, wordt er een lokale mutex gemaakt, alsof u de Mutex(Boolean) constructor had aangeroepen.

Omdat ze systeembreed zijn, kunnen benoemde mutexes worden gebruikt om het resourcegebruik over procesgrenzen te coördineren.

De backslash (\) is een gereserveerd teken in een mutex-naam. Gebruik geen backslash (\) in een mutex-naam, behalve zoals opgegeven in de opmerking over het gebruik van mutexes in terminalserversessies. Anders kan er een DirectoryNotFoundException worden gegenereerd, ook al vertegenwoordigt de naam van de mutex een bestaand bestand.

Zie ook

• Het Beheerd Draadbeheer
• Mutexes-

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

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

Parameters

Kenmerken

SecurityCriticalAttribute

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u hoe een benoemde mutex wordt gebruikt om tussen processen of threads te signaleren. Voer dit programma uit vanuit twee of meer opdrachtvensters. Elk proces maakt een Mutex object dat de benoemde mutex 'MyMutex' vertegenwoordigt. De naam mutex is een systeemobject. In dit voorbeeld is de levensduur gebonden aan de levensduur van de Mutex objecten die deze vertegenwoordigen. De benoemde mutex wordt gemaakt wanneer het eerste proces het lokale Mutex object maakt en vernietigd wanneer alle Mutex objecten die het vertegenwoordigen, zijn vrijgegeven. De benoemde mutex is in eerste instantie eigendom van het eerste proces. Het tweede proces en eventuele volgende processen wachten totdat eerdere processen de benoemde mutex vrijgeven.

// 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

Opmerkingen

De name naamruimte kan worden voorafgegaan door Global\ of Local\ om een naamruimte op te geven. Wanneer de Global naamruimte is opgegeven, kan het synchronisatieobject worden gedeeld met processen op het systeem. Wanneer de Local naamruimte is opgegeven, wat ook de standaardwaarde is wanneer er geen naamruimte is opgegeven, kan het synchronisatieobject worden gedeeld met processen in dezelfde sessie. Op Windows is een sessie een aanmeldingssessie en worden services meestal uitgevoerd in een andere niet-interactieve sessie. Op Unix-achtige besturingssystemen heeft elke shell een eigen sessie. Sessie-lokale synchronisatieobjecten zijn mogelijk geschikt voor synchronisatie tussen processen met een bovenliggende/onderliggende relatie, waar ze allemaal in dezelfde sessie worden uitgevoerd. Zie Objectnamen voor meer informatie over de namen van synchronisatieobjecten in Windows.

Als er een name is opgegeven en er al een synchronisatieobject van het aangevraagde type bestaat in de naamruimte, wordt het bestaande synchronisatieobject gebruikt. Als er al een synchronisatieobject van een ander type bestaat in de naamruimte, wordt er een WaitHandleCannotBeOpenedException gegenereerd. Anders wordt er een nieuw synchronisatieobject gemaakt.

Als name dat niet null het is en initiallyOwned is true, is de aanroepende thread alleen eigenaar van de benoemde mutex als createdNew deze zich true na de aanroep bevindt. Anders kan de thread de mutex aanvragen door de methode aan te WaitOne roepen.

Met deze constructor wordt een Mutex object geïnitialiseerd dat een benoemde systeemmutex vertegenwoordigt. U kunt meerdere Mutex objecten maken die dezelfde benoemde systeemmutex vertegenwoordigen.

Als de benoemde mutex al is gemaakt met beveiliging van toegangsbeheer en de beller geen rechten heeft MutexRights.FullControl , wordt er een uitzondering gegenereerd. Als u een bestaande benoemde mutex wilt openen met alleen de machtigingen die nodig zijn voor het synchroniseren van threadactiviteiten, raadpleegt u de OpenExisting methode.

Als u opgeeft null of een lege tekenreeks voor name, wordt er een lokale mutex gemaakt, alsof u de Mutex(Boolean) constructor had aangeroepen. In dit geval createdNew is dat altijd true.

Omdat ze systeembreed zijn, kunnen benoemde mutexes worden gebruikt om het resourcegebruik over procesgrenzen te coördineren.

De backslash (\) is een gereserveerd teken in een mutex-naam. Gebruik geen backslash (\) in een mutex-naam, behalve zoals opgegeven in de opmerking over het gebruik van mutexes in terminalserversessies. Anders kan er een DirectoryNotFoundException worden gegenereerd, ook al vertegenwoordigt de naam van de mutex een bestaand bestand.

Zie ook

• Het Beheerd Draadbeheer
• Mutexes-

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)

Parameters

Kenmerken

SecurityCriticalAttribute

Uitzonderingen

Voorbeelden

In het volgende codevoorbeeld ziet u het gedrag tussen processen van een benoemde mutex met beveiliging van toegangsbeheer. In het voorbeeld wordt de overbelasting van de OpenExisting(String) methode gebruikt om te testen op het bestaan van een benoemde mutex.

Als de mutex niet bestaat, wordt deze gemaakt met de eerste eigendoms- en toegangsbeheerbeveiliging die de huidige gebruiker het recht weigert om de mutex te gebruiken, maar verleent het recht om machtigingen voor lezen en wijzigen voor de mutex te lezen en te wijzigen.

Als u het gecompileerde voorbeeld uitvoert vanuit twee opdrachtvensters, genereert de tweede kopie een uitzondering voor toegangsschending bij de aanroep naar OpenExisting(String). De uitzondering wordt gevangen en in het voorbeeld wordt de overbelasting van de OpenExisting(String, MutexRights) methode gebruikt om de mutex te openen met de rechten die nodig zijn om de machtigingen te lezen en te wijzigen.

Nadat de machtigingen zijn gewijzigd, wordt de mutex geopend met de rechten die nodig zijn om deze in te voeren en vrij te geven. Als u het gecompileerde voorbeeld uitvoert vanuit een derde opdrachtvenster, wordt het uitgevoerd met behulp van de nieuwe machtigingen.

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

Opmerkingen

De name naamruimte kan worden voorafgegaan door Global\ of Local\ om een naamruimte op te geven. Wanneer de Global naamruimte is opgegeven, kan het synchronisatieobject worden gedeeld met processen op het systeem. Wanneer de Local naamruimte is opgegeven, wat ook de standaardwaarde is wanneer er geen naamruimte is opgegeven, kan het synchronisatieobject worden gedeeld met processen in dezelfde sessie. Op Windows is een sessie een aanmeldingssessie en worden services meestal uitgevoerd in een andere niet-interactieve sessie. Op Unix-achtige besturingssystemen heeft elke shell een eigen sessie. Sessie-lokale synchronisatieobjecten zijn mogelijk geschikt voor synchronisatie tussen processen met een bovenliggende/onderliggende relatie, waar ze allemaal in dezelfde sessie worden uitgevoerd. Zie Objectnamen voor meer informatie over de namen van synchronisatieobjecten in Windows.

Als er een name is opgegeven en er al een synchronisatieobject van het aangevraagde type bestaat in de naamruimte, wordt het bestaande synchronisatieobject gebruikt. Als er al een synchronisatieobject van een ander type bestaat in de naamruimte, wordt er een WaitHandleCannotBeOpenedException gegenereerd. Anders wordt er een nieuw synchronisatieobject gemaakt.

Als name dat niet null het is en initiallyOwned is true, is de aanroepende thread alleen eigenaar van de benoemde mutex als createdNew deze zich true na de aanroep bevindt. Anders kan de thread de mutex aanvragen door de methode aan te WaitOne roepen.

Gebruik deze constructor om toegangsbeheerbeveiliging toe te passen op een benoemde systeemmutex wanneer deze wordt gemaakt, zodat andere code de controle over de mutex kan overnemen.

Met deze constructor wordt een Mutex object geïnitialiseerd dat een benoemde systeemmutex vertegenwoordigt. U kunt meerdere Mutex objecten maken die dezelfde benoemde systeemmutex vertegenwoordigen.

Als de benoemde systeemmutex niet bestaat, wordt deze gemaakt met de opgegeven beveiliging voor toegangsbeheer. Als de benoemde mutex bestaat, wordt de opgegeven beveiliging voor toegangsbeheer genegeerd.

Als de benoemde mutex al is gemaakt met toegangsbeheerbeveiliging en de beller niet beschikt MutexRights.FullControl, wordt er een uitzondering gegenereerd. Als u een bestaande benoemde mutex wilt openen met alleen de machtigingen die nodig zijn voor het synchroniseren van threadactiviteiten, raadpleegt u de OpenExisting methode.

Als u opgeeft null of een lege tekenreeks voor name, wordt er een lokale mutex gemaakt, alsof u de Mutex(Boolean) constructor had aangeroepen. In dit geval createdNew is dat altijd true.

Omdat ze systeembreed zijn, kunnen benoemde mutexes worden gebruikt om het resourcegebruik over procesgrenzen te coördineren.

De backslash (\) is een gereserveerd teken in een mutex-naam. Gebruik geen backslash (\) in een mutex-naam, behalve zoals opgegeven in de opmerking over het gebruik van mutexes in terminalserversessies. Anders kan er een DirectoryNotFoundException worden gegenereerd, ook al vertegenwoordigt de naam van de mutex een bestaand bestand.