Mutex Konstruktorer

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

public:
 Mutex();

public Mutex();

Public Sub New ()

Exempel

Följande kodexempel visar hur ett lokalt Mutex objekt används för att synkronisera åtkomst till en skyddad resurs. Tråden som skapar mutex äger den inte från början.

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

Kommentarer

Att anropa den här konstruktorns överlagring är samma sak som att anropa Mutex(Boolean) konstruktorns överlagring och ange false för inledande ägarskap för mutexen. Det innebär att den anropande tråden inte äger mutex.

Se även

• hanterad trådning
• mutexes

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

public:
 Mutex(bool initiallyOwned);

public Mutex(bool initiallyOwned);

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

Public Sub New (initiallyOwned As Boolean)

Parametrar

Exempel

Följande kodexempel visar hur ett lokalt Mutex objekt används för att synkronisera åtkomst till en skyddad resurs. Tråden som skapar äger den Mutex från början.

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

Se även

• hanterad trådning
• mutexes

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

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)

Parametrar

Attribut

SecurityCriticalAttribute

Undantag

Exempel

I följande exempel visas hur en namngiven mutex används för att signalera mellan trådar som körs i två separata processer.

Kör det här programmet från två eller flera kommandofönster. Varje process skapar ett Mutex objekt som representerar den namngivna mutexen MyMutex. Det namngivna mutex-objektet är ett systemobjekt vars livslängd begränsas av livslängden för de Mutex objekt som representerar det. Det namngivna mutexet skapas när den första processen skapar objektet Mutex . I det här exemplet ägs den namngivna mutexen av den första processen som kör programmet. Den namngivna mutexen förstörs när alla Mutex objekt som representerar det har släppts.

Den överlagring av konstruktorn som används i det här exemplet kan inte tala om för den anropande tråden om det ursprungliga ägarskapet för det namngivna mutexet har beviljats. Du bör inte använda den här konstruktorn för att begära inledande ägarskap om du inte kan vara säker på att tråden skapar den namngivna mutexen.

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

Kommentarer

name Kan vara prefix med Global\ eller Local\ för att ange ett namnområde. Global När namnområdet har angetts kan synkroniseringsobjektet delas med alla processer i systemet. Local När namnområdet har angetts, vilket också är standard när inget namnområde anges, kan synkroniseringsobjektet delas med processer i samma session. På Windows är en session en inloggningssession och tjänster körs vanligtvis i en annan icke-interaktiv session. På Unix-liknande operativsystem har varje gränssnitt en egen session. Sessionslokala synkroniseringsobjekt kan vara lämpliga för synkronisering mellan processer med en överordnad/underordnad relation där alla körs i samma session. Mer information om synkroniseringsobjektnamn på Windows finns i Object Names.

Om en name tillhandahålls och det redan finns ett synkroniseringsobjekt av den begärda typen i namnområdet används det befintliga synkroniseringsobjektet. Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Om name är inte null och initiallyOwned är true, äger den anropande tråden endast mutex om den namngivna system mutexen skapades som ett resultat av det här anropet. Eftersom det inte finns någon mekanism för att avgöra om den namngivna system mutex skapades är det bättre att ange false för initiallyOwned när du anropar den här konstruktorns överlagring. Du kan använda Mutex(Boolean, String, Boolean) konstruktorn om du behöver fastställa det ursprungliga ägarskapet.

Den här konstruktorn initierar ett Mutex objekt som representerar en namngiven system mutex. Du kan skapa flera Mutex objekt som representerar samma namngivna system mutex.

Om den namngivna mutexen redan har skapats med åtkomstkontrollsäkerhet och anroparen inte har MutexRights.FullControl, utlöses ett undantag. Information om hur du öppnar en befintlig med namnet mutex med endast de behörigheter som krävs för synkronisering av trådaktiviteter finns i OpenExisting metoden.

Om du anger null eller en tom sträng för nameskapas en lokal mutex, som om du hade anropat Mutex(Boolean) konstruktorn.

Eftersom de är systemomfattande kan namngivna mutexer användas för att samordna resursanvändning över processgränser.

Omvänt snedstreck (\) är ett reserverat tecken i ett mutex-namn. Använd inte ett omvänt snedstreck (\) i ett mutex-namn förutom det som anges i anteckningen om att använda mutex i terminalserversessioner. Annars kan en DirectoryNotFoundException genereras, även om namnet på mutex representerar en befintlig fil.

Se även

• hanterad trådning
• mutexes

Källa:

Mutex.cs

Källa:

Mutex.cs

public:
 Mutex(System::String ^ name, System::Threading::NamedWaitHandleOptions options);

public Mutex(string? name, System.Threading.NamedWaitHandleOptions options);

new System.Threading.Mutex : string * System.Threading.NamedWaitHandleOptions -> System.Threading.Mutex

Public Sub New (name As String, options As NamedWaitHandleOptions)

Parametrar

Undantag

Kommentarer

Om en name tillhandahålls och det redan finns ett synkroniseringsobjekt av den begärda typen i namnområdet används det befintliga synkroniseringsobjektet, men om options anger åtkomst som är begränsad till den aktuella användaren och synkroniseringsobjektet inte är kompatibelt med det genereras en WaitHandleCannotBeOpenedException . Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras även ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Den här konstruktorn initierar ett Mutex objekt som representerar en namngiven system mutex. Du kan skapa flera Mutex objekt som representerar samma namngivna system mutex.

Om den namngivna mutexen redan har skapats med åtkomstkontrollsäkerhet och anroparen inte har MutexRights.FullControl, utlöses ett undantag. Information om hur du öppnar en befintlig med namnet mutex med endast de behörigheter som krävs för synkronisering av trådaktiviteter finns i OpenExisting metoden.

Om du anger null eller en tom sträng för nameskapas en lokal mutex, som om du hade anropat Mutex(Boolean) konstruktorn.

Eftersom de är systemomfattande kan namngivna mutexer användas för att samordna resursanvändning över processgränser.

Parametern options kan anges för att ange om den namngivna mutexen endast är tillgänglig för den aktuella användaren eller för alla användare. Du kan också ange om den namngivna mutexen endast är tillgänglig för processer i den aktuella sessionen eller för alla sessioner. Mer information finns i NamedWaitHandleOptions.

Omvänt snedstreck (\) är ett reserverat tecken i ett mutex-namn. Använd inte ett omvänt snedstreck (\) i ett mutex-namn förutom det som anges i anteckningen om att använda mutex i terminalserversessioner. Annars kan en DirectoryNotFoundException genereras, även om namnet på mutex representerar en befintlig fil.

Se även

• hanterad trådning
• mutexes

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

Källa:

Mutex.cs

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)

Parametrar

Attribut

SecurityCriticalAttribute

Undantag

Exempel

Följande kodexempel visar hur ett namngivet mutex används för att signalera mellan processer eller trådar. Kör det här programmet från två eller flera kommandofönster. Varje process skapar ett Mutex objekt som representerar den namngivna mutexen "MyMutex". Den namngivna mutexen är ett systemobjekt. I det här exemplet begränsas dess livslängd av livslängden för de Mutex objekt som representerar det. Den namngivna mutexen skapas när den första processen skapar sitt lokala Mutex objekt och förstörs när alla Mutex objekt som representerar det har släppts. Den namngivna mutexen ägs ursprungligen av den första processen. Den andra processen och efterföljande processer väntar på att tidigare processer ska släppa den namngivna mutexen.

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

Kommentarer

name Kan vara prefix med Global\ eller Local\ för att ange ett namnområde. Global När namnområdet har angetts kan synkroniseringsobjektet delas med alla processer i systemet. Local När namnområdet har angetts, vilket också är standard när inget namnområde anges, kan synkroniseringsobjektet delas med processer i samma session. På Windows är en session en inloggningssession och tjänster körs vanligtvis i en annan icke-interaktiv session. På Unix-liknande operativsystem har varje gränssnitt en egen session. Sessionslokala synkroniseringsobjekt kan vara lämpliga för synkronisering mellan processer med en överordnad/underordnad relation där alla körs i samma session. Mer information om synkroniseringsobjektnamn på Windows finns i Object Names.

Om en name tillhandahålls och det redan finns ett synkroniseringsobjekt av den begärda typen i namnområdet används det befintliga synkroniseringsobjektet. Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Om name är inte null och initiallyOwned är trueäger den anropande tråden endast namnet mutex om createdNew är true efter anropet. Annars kan tråden begära mutex genom att anropa WaitOne metoden.

Den här konstruktorn initierar ett Mutex objekt som representerar en namngiven system mutex. Du kan skapa flera Mutex objekt som representerar samma namngivna system mutex.

Om den namngivna mutexen redan har skapats med åtkomstkontrollsäkerhet och anroparen inte har MutexRights.FullControl rättigheter utlöses ett undantag. Information om hur du öppnar en befintlig med namnet mutex med endast de behörigheter som krävs för synkronisering av trådaktiviteter finns i OpenExisting metoden.

Om du anger null eller en tom sträng för nameskapas en lokal mutex, som om du hade anropat Mutex(Boolean) konstruktorn. I det här fallet createdNew är alltid true.

Eftersom de är systemomfattande kan namngivna mutexer användas för att samordna resursanvändning över processgränser.

Omvänt snedstreck (\) är ett reserverat tecken i ett mutex-namn. Använd inte ett omvänt snedstreck (\) i ett mutex-namn förutom det som anges i anteckningen om att använda mutex i terminalserversessioner. Annars kan en DirectoryNotFoundException genereras, även om namnet på mutex representerar en befintlig fil.

Se även

• hanterad trådning
• mutexes

Källa:

Mutex.cs

Källa:

Mutex.cs

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

public Mutex(bool initiallyOwned, string? name, System.Threading.NamedWaitHandleOptions options);

new System.Threading.Mutex : bool * string * System.Threading.NamedWaitHandleOptions -> System.Threading.Mutex

Public Sub New (initiallyOwned As Boolean, name As String, options As NamedWaitHandleOptions)

Parametrar

Undantag

Kommentarer

Om en name tillhandahålls och det redan finns ett synkroniseringsobjekt av den begärda typen i namnområdet används det befintliga synkroniseringsobjektet, men om options anger åtkomst som är begränsad till den aktuella användaren och synkroniseringsobjektet inte är kompatibelt med det genereras en WaitHandleCannotBeOpenedException . Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras även ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Om name är inte null och initiallyOwned är true, äger den anropande tråden endast mutex om den namngivna system mutexen skapades som ett resultat av det här anropet. Eftersom det inte finns någon mekanism för att avgöra om den namngivna system mutex skapades är det bättre att ange false för initiallyOwned när du anropar den här konstruktorns överlagring. Du kan använda Mutex(Boolean, String, Boolean) konstruktorn om du behöver fastställa det ursprungliga ägarskapet.

Den här konstruktorn initierar ett Mutex objekt som representerar en namngiven system mutex. Du kan skapa flera Mutex objekt som representerar samma namngivna system mutex.

Om den namngivna mutexen redan har skapats med åtkomstkontrollsäkerhet och anroparen inte har MutexRights.FullControl, utlöses ett undantag. Information om hur du öppnar en befintlig med namnet mutex med endast de behörigheter som krävs för synkronisering av trådaktiviteter finns i OpenExisting metoden.

Om du anger null eller en tom sträng för nameskapas en lokal mutex, som om du hade anropat Mutex(Boolean) konstruktorn.

Eftersom de är systemomfattande kan namngivna mutexer användas för att samordna resursanvändning över processgränser.

Parametern options kan anges för att ange om den namngivna mutexen endast är tillgänglig för den aktuella användaren eller för alla användare. Du kan också ange om den namngivna mutexen endast är tillgänglig för processer i den aktuella sessionen eller för alla sessioner. Mer information finns i NamedWaitHandleOptions.

Se även

• hanterad trådning
• 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)

Parametrar

Attribut

SecurityCriticalAttribute

Undantag

Exempel

Följande kodexempel visar beteendet mellan processer för en namngiven mutex med åtkomstkontrollsäkerhet. I exemplet används metodöverbelastningen OpenExisting(String) för att testa förekomsten av en namngiven mutex.

Om mutexen inte finns skapas den med inledande ägarskap och åtkomstkontrollsäkerhet som nekar den aktuella användaren rätten att använda mutex, men ger behörighet att läsa och ändra behörigheter för mutex.

Om du kör det kompilerade exemplet från två kommandofönster utlöser den andra kopian ett undantag om åtkomstöverträdelse i anropet till OpenExisting(String). Undantaget fångas och i exemplet används OpenExisting(String, MutexRights) metodens överlagring för att öppna mutex med de rättigheter som krävs för att läsa och ändra behörigheterna.

När behörigheterna har ändrats öppnas mutex med de rättigheter som krävs för att ange och släppa den. Om du kör det kompilerade exemplet från ett tredje kommandofönster körs det med de nya behörigheterna.

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

Kommentarer

name Kan vara prefix med Global\ eller Local\ för att ange ett namnområde. Global När namnområdet har angetts kan synkroniseringsobjektet delas med alla processer i systemet. Local När namnområdet har angetts, vilket också är standard när inget namnområde anges, kan synkroniseringsobjektet delas med processer i samma session. På Windows är en session en inloggningssession och tjänster körs vanligtvis i en annan icke-interaktiv session. På Unix-liknande operativsystem har varje gränssnitt en egen session. Sessionslokala synkroniseringsobjekt kan vara lämpliga för synkronisering mellan processer med en överordnad/underordnad relation där alla körs i samma session. Mer information om synkroniseringsobjektnamn på Windows finns i Object Names.

Om en name tillhandahålls och det redan finns ett synkroniseringsobjekt av den begärda typen i namnområdet används det befintliga synkroniseringsobjektet. Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Om name är inte null och initiallyOwned är trueäger den anropande tråden endast namnet mutex om createdNew är true efter anropet. Annars kan tråden begära mutex genom att anropa WaitOne metoden.

Använd den här konstruktorn för att tillämpa åtkomstkontrollsäkerhet på en namngiven system mutex när den skapas, vilket förhindrar att annan kod tar kontroll över mutex.

Den här konstruktorn initierar ett Mutex objekt som representerar en namngiven system mutex. Du kan skapa flera Mutex objekt som representerar samma namngivna system mutex.

Om den namngivna system mutexen inte finns skapas den med den angivna åtkomstkontrollsäkerheten. Om den namngivna mutexen finns ignoreras den angivna åtkomstkontrollsäkerheten.

Om den namngivna mutexen redan har skapats med åtkomstkontrollsäkerhet och anroparen inte har MutexRights.FullControl, utlöses ett undantag. Information om hur du öppnar en befintlig med namnet mutex med endast de behörigheter som krävs för synkronisering av trådaktiviteter finns i OpenExisting metoden.

Om du anger null eller en tom sträng för nameskapas en lokal mutex, som om du hade anropat Mutex(Boolean) konstruktorn. I det här fallet createdNew är alltid true.

Eftersom de är systemomfattande kan namngivna mutexer användas för att samordna resursanvändning över processgränser.

Omvänt snedstreck (\) är ett reserverat tecken i ett mutex-namn. Använd inte ett omvänt snedstreck (\) i ett mutex-namn förutom det som anges i anteckningen om att använda mutex i terminalserversessioner. Annars kan en DirectoryNotFoundException genereras, även om namnet på mutex representerar en befintlig fil.

Källa:

Mutex.cs

Källa:

Mutex.cs

public:
 Mutex(bool initiallyOwned, System::String ^ name, System::Threading::NamedWaitHandleOptions options, [Runtime::InteropServices::Out] bool % createdNew);

public Mutex(bool initiallyOwned, string? name, System.Threading.NamedWaitHandleOptions options, out bool createdNew);

new System.Threading.Mutex : bool * string * System.Threading.NamedWaitHandleOptions * bool -> System.Threading.Mutex

Public Sub New (initiallyOwned As Boolean, name As String, options As NamedWaitHandleOptions, ByRef createdNew As Boolean)

Parametrar

Undantag

Kommentarer

Om en name tillhandahålls och det redan finns ett synkroniseringsobjekt av den begärda typen i namnområdet används det befintliga synkroniseringsobjektet, men om options anger åtkomst som är begränsad till den aktuella användaren och synkroniseringsobjektet inte är kompatibelt med det genereras en WaitHandleCannotBeOpenedException . Om det redan finns ett synkroniseringsobjekt av en annan typ i namnområdet genereras även ett WaitHandleCannotBeOpenedException . Annars skapas ett nytt synkroniseringsobjekt.

Om name är inte null och initiallyOwned är trueäger den anropande tråden endast namnet mutex om createdNew är true efter anropet. Annars kan tråden begära mutex genom att anropa WaitOne metoden.

Den här konstruktorn initierar ett Mutex objekt som representerar en namngiven system mutex. Du kan skapa flera Mutex objekt som representerar samma namngivna system mutex.

Om den namngivna mutexen redan har skapats med åtkomstkontrollsäkerhet och anroparen inte har MutexRights.FullControl rättigheter utlöses ett undantag. Information om hur du öppnar en befintlig med namnet mutex med endast de behörigheter som krävs för synkronisering av trådaktiviteter finns i OpenExisting metoden.

Om du anger null eller en tom sträng för nameskapas en lokal mutex, som om du hade anropat Mutex(Boolean) konstruktorn. I det här fallet createdNew är alltid true.

Eftersom de är systemomfattande kan namngivna mutexer användas för att samordna resursanvändning över processgränser.

Parametern options kan anges för att ange om den namngivna mutexen endast är tillgänglig för den aktuella användaren eller för alla användare. Du kan också ange om den namngivna mutexen endast är tillgänglig för processer i den aktuella sessionen eller för alla sessioner. Mer information finns i NamedWaitHandleOptions.

Se även

• hanterad trådning
• mutexes