Sdílet prostřednictvím


Mutex Konstruktory

Definice

Inicializuje novou instanci Mutex třídy .

Přetížení

Mutex()

Inicializuje novou instanci třídy s výchozími Mutex vlastnostmi.

Mutex(Boolean)

Inicializuje novou instanci Mutex třídy s logickou hodnotou, která označuje, zda má volající vlákno mít počáteční vlastnictví mutex.

Mutex(Boolean, String)

Inicializuje novou instanci Mutex třídy s logickou hodnotou, která označuje, zda má volající vlákno mít počáteční vlastnictví mutex, a řetězec, který je názvem mutex.

Mutex(Boolean, String, Boolean)

Inicializuje novou instanci Mutex třídy s logickou hodnotou, která označuje, zda volající vlákno má mít počáteční vlastnictví mutex, řetězec, který je název mutex, a logická hodnota, která, když metoda vrátí, označuje, zda volající vlákno bylo uděleno počáteční vlastnictví mutex.

Mutex(Boolean, String, Boolean, MutexSecurity)

Inicializuje novou instanci Mutex třídy s logickou hodnotou, která označuje, zda volající vlákno má mít počáteční vlastnictví mutex, řetězec, který je název mutex, logická proměnná, která, když metoda vrátí, označuje, zda volající vlákno bylo uděleno počáteční vlastnictví mutexu, a zabezpečení řízení přístupu, které se má použít na pojmenovaný mutex.

Mutex()

Zdroj:
Mutex.cs
Zdroj:
Mutex.cs
Zdroj:
Mutex.cs

Inicializuje novou instanci třídy s výchozími Mutex vlastnostmi.

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

Příklady

Následující příklad kódu ukazuje, jak se místní Mutex objekt používá k synchronizaci přístupu k chráněnému prostředku. Vlákno, které vytváří mutex, ho zpočátku nevlastní.

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

Poznámky

Volání tohoto přetížení konstruktoru je stejné jako volání přetížení konstruktoru Mutex(Boolean) a určení false počátečního vlastnictví mutexu. To znamená, že volající vlákno nevlastní mutex.

Viz také

Platí pro

Mutex(Boolean)

Zdroj:
Mutex.cs
Zdroj:
Mutex.cs
Zdroj:
Mutex.cs

Inicializuje novou instanci Mutex třídy s logickou hodnotou, která označuje, zda má volající vlákno mít počáteční vlastnictví mutex.

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

Parametry

initiallyOwned
Boolean

truek poskytnutí počátečního vlastnictví volajícího vlákna mutexu; v opačném případě . false

Příklady

Následující příklad kódu ukazuje, jak se místní Mutex objekt používá k synchronizaci přístupu k chráněnému prostředku. Vlákno, které vytvoří, ho Mutex zpočátku vlastní.

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

Viz také

Platí pro

Mutex(Boolean, String)

Zdroj:
Mutex.cs
Zdroj:
Mutex.cs
Zdroj:
Mutex.cs

Inicializuje novou instanci Mutex třídy s logickou hodnotou, která označuje, zda má volající vlákno mít počáteční vlastnictví mutex, a řetězec, který je názvem mutex.

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)

Parametry

initiallyOwned
Boolean

truek poskytnutí počátečního vlastnictví volajícího vlákna pojmenovaného systémového mutexu, pokud je v důsledku tohoto volání vytvořen pojmenovaný systémový mutex; v opačném případě . false

name
String

Název, pokud synchronizační objekt má být sdílen s jinými procesy; null nebo prázdný řetězec. V názvu se rozlišují velká a malá písmena. Znak zpětného lomítka (\) je vyhrazený a lze ho použít pouze k určení oboru názvů. Další informace o oborech názvů najdete v části s poznámkami. V závislosti na operačním systému můžou existovat další omezení pro název. Například v operačních systémech se systémem Unix musí být název po vyloučení oboru názvů platný název souboru.

Atributy

Výjimky

Pojmenovaný mutex existuje a má zabezpečení řízení přístupu, ale uživatel nemá FullControl.

Formát name je neplatný. Může to být z různých důvodů, včetně některých omezení, která může operační systém umístit, jako je neznámá předpona nebo neplatné znaky. Všimněte si, že v názvu a běžných předponách Global a Local se rozlišují velká a malá písmena.

-nebo-

Došlo k jiné chybě. Vlastnost HResult může poskytnout další informace.

Pouze windows: name zadaný neznámý obor názvů. Další informace najdete v tématu Názvy objektů .

Je name moc dlouhý. Omezení délky mohou záviset na operačním systému nebo konfiguraci.

Objekt synchronizace se zadaným name objektem nelze vytvořit. Objekt synchronizace jiného typu může mít stejný název.

Pouze rozhraní .NET Framework: name je delší než MAX_PATH (260 znaků).

Příklady

Následující příklad ukazuje, jak se pojmenovaný mutex používá k signálu mezi vlákny spuštěnými ve dvou samostatných procesech.

Spusťte tento program ze dvou nebo více oken příkazů. Každý proces vytvoří Mutex objekt, který představuje pojmenovaný mutex MyMutex. Pojmenovaný mutex je systémový objekt, jehož životnost je ohraničena životností objektů, které ho Mutex představují. Pojmenovaný mutex se vytvoří, když první proces vytvoří svůj Mutex objekt. V tomto příkladu je pojmenovaný mutex vlastněný prvním procesem, který program spouští. Pojmenovaný mutex je zničen, když byly uvolněny všechny Mutex objekty, které ho představují.

Přetížení konstruktoru použité v tomto příkladu nemůže říct volajícímu vláknu, jestli bylo uděleno počáteční vlastnictví pojmenovaného mutexu. Tento konstruktor byste neměli používat k vyžádání počátečního vlastnictví, pokud si nejste jistí, že vlákno vytvoří pojmenovaný mutex.

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

Poznámky

Předpona nameGlobal\ může mít předponu nebo Local\ k určení oboru názvů. Při zadání Global oboru názvů může být synchronizační objekt sdílen s libovolnými procesy v systému. Local Pokud je zadán obor názvů, což je také výchozí, pokud není zadán žádný obor názvů, synchronizační objekt může být sdílen s procesy ve stejné relaci. V systému Windows je relace přihlášení a služby obvykle běží v jiné neinteraktivní relaci. V unixových operačních systémech má každé prostředí svoji vlastní relaci. Objekty místní synchronizace relace mohou být vhodné pro synchronizaci mezi procesy s nadřazeným a podřízeným vztahem, kde se všechny spouští ve stejné relaci. Další informace o názvech objektů synchronizace ve Windows najdete v tématu Názvy objektů.

name Pokud je zadán objekt synchronizace požadovaného typu již existuje v oboru názvů, použije se existující objekt synchronizace. Pokud v oboru názvů již existuje objekt synchronizace jiného typu, WaitHandleCannotBeOpenedException vyvolá se objekt . V opačném případě se vytvoří nový objekt synchronizace.

Pokud name není null a initiallyOwned je true, volající vlákno vlastní mutex pouze v případě, že pojmenovaný systémový mutex byl vytvořen v důsledku tohoto volání. Vzhledem k tomu, že neexistuje žádný mechanismus pro určení, zda pojmenovaný systémový mutex byl vytvořen, je lepší zadat false pro initiallyOwned při volání tohoto přetížení konstruktoru. Konstruktor můžete použít, Mutex(Boolean, String, Boolean) pokud potřebujete určit počáteční vlastnictví.

Tento konstruktor inicializuje Mutex objekt, který představuje pojmenovaný systémový mutex. Můžete vytvořit více Mutex objektů, které představují stejný pojmenovaný systémový mutex.

Pokud již byl pojmenovaný mutex vytvořen se zabezpečením řízení přístupu a volající nemá MutexRights.FullControl, vyvolá se výjimka. Pokud chcete otevřít existující pojmenovaný mutex pouze s oprávněními potřebnými pro synchronizaci aktivit vláken, projděte si metodu OpenExisting .

Pokud zadáte null nebo prázdný řetězec pro name, vytvoří se místní mutex, jako byste volali Mutex(Boolean) konstruktor. V tomto případě createdNew je vždy true.

Vzhledem k tomu, že se jedná o celé systémy, je možné pojmenované mutexy použít ke koordinaci využití prostředků napříč hranicemi procesů.

Poznámka

Na serveru, na kterém běží Terminálová služba, může mít pojmenovaný systémový mutex dvě úrovně viditelnosti. Pokud jeho název začíná předponou Global\, je mutex viditelný ve všech relacích terminálového serveru. Pokud jeho název začíná předponou Local\, je mutex viditelný pouze v relaci terminálového serveru, kde byl vytvořen. V takovém případě může v každé další relaci terminálového serveru na serveru existovat samostatný mutex se stejným názvem. Pokud při vytváření pojmenovaného mutexu nezadáte předponu, převezme předponu Local\. V relaci terminálového serveru jsou dva mutexy, jejichž názvy se liší pouze svými předponami, samostatné mutexy a oba jsou viditelné pro všechny procesy v relaci terminálového serveru. To znamená, že názvy Global\ předpon a Local\ popisují obor názvu mutex vzhledem k relacím terminálového serveru, nikoli vzhledem k procesům.

Upozornění

Ve výchozím nastavení není pojmenovaný mutex omezen na uživatele, který ho vytvořil. Jiní uživatelé můžou mutex otevřít a používat, včetně narušení mutexu tím, že do mutexu vstoupí a neopouští ho. V unixových operačních systémech se systém souborů používá při implementaci pojmenovaných mutexů a jiní uživatelé mohou být schopni ovlivňovat pojmenované mutexy významnějšími způsoby. Pokud chcete ve Windows omezit přístup na konkrétní uživatele, můžete při vytváření pojmenovaného mutexu použít přetížení konstruktoru nebo MutexAcl předat MutexSecurity . V unixových operačních systémech v současné době neexistuje způsob, jak omezit přístup k pojmenovaným mutexům. Vyhněte se používání pojmenovaných mutexů bez omezení přístupu v systémech, které můžou mít nedůvěryhodné uživatele s kódem.

Zpětné lomítko (\) je vyhrazený znak v názvu mutex. Nepoužívejte zpětné lomítko (\) v názvu mutexu s výjimkou případů uvedených v poznámce o použití mutexů v relacích terminálového serveru. V opačném DirectoryNotFoundException případě může být vyvolán, i když název mutex představuje existující soubor.

Viz také

Platí pro

Mutex(Boolean, String, Boolean)

Zdroj:
Mutex.cs
Zdroj:
Mutex.cs
Zdroj:
Mutex.cs

Inicializuje novou instanci Mutex třídy s logickou hodnotou, která označuje, zda volající vlákno by mělo mít počáteční vlastnictví mutex, řetězec, který je název mutex, a logická hodnota, která, když metoda vrátí, označuje, zda volající vlákno bylo uděleno počáteční vlastnictví mutex.

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)

Parametry

initiallyOwned
Boolean

truedát volající vlákno počáteční vlastnictví pojmenovaný system mutex pokud pojmenovaný system mutex je vytvořen jako výsledek tohoto volání; v opačném případě . false

name
String

Název, pokud synchronizační objekt má být sdílen s jinými procesy; null nebo prázdný řetězec. V názvu se rozlišují velká a malá písmena. Znak zpětného lomítka (\) je vyhrazený a lze ho použít pouze k určení oboru názvů. Další informace o oborech názvů najdete v části poznámky. V závislosti na operačním systému můžou existovat další omezení názvu. Například v unixových operačních systémech musí být název po vyloučení oboru názvů platný název souboru.

createdNew
Boolean

Když se tato metoda vrátí, obsahuje logickou hodnotu, která znamená true , že byl vytvořen místní mutex (tj. pokud name je null nebo prázdný řetězec) nebo byl vytvořen zadaný pojmenovaný systémový mutex; false pokud zadaný pojmenovaný systémový mutex již existoval. Tento parametr se předává neinicializovaný.

Atributy

Výjimky

Pojmenovaný mutex existuje a má zabezpečení řízení přístupu, ale uživatel nemá FullControl.

Formát name je neplatný. Může to být z různých důvodů, včetně některých omezení, která může operační systém použít, například kvůli neznámé předponě nebo neplatným znakům. Všimněte si, že názvy a běžné předpony Global a Local rozlišují malá a velká písmena.

-nebo-

Došlo k jiné chybě. Vlastnost HResult může poskytnout další informace.

Pouze windows: name zadal neznámý obor názvů. Další informace najdete v tématu Názvy objektů .

Je name příliš dlouhý. Omezení délky může záviset na operačním systému nebo konfiguraci.

Synchronizační objekt se zadaným name objektem nelze vytvořit. Objekt synchronizace jiného typu může mít stejný název.

Pouze rozhraní .NET Framework: name je delší než MAX_PATH (260 znaků).

Příklady

Následující příklad kódu ukazuje, jak se pojmenovaný mutex používá k signálu mezi procesy nebo vlákny. Spusťte tento program ze dvou nebo více oken příkazů. Každý proces vytvoří Mutex objekt, který představuje pojmenovaný mutex MyMutex. Pojmenovaný mutex je systémový objekt. V tomto příkladu je jeho životnost omezena životností Mutex objektů, které ji představují. Pojmenovaný mutex se vytvoří, když první proces vytvoří místní Mutex objekt, a po uvolnění všech objektů, které ho Mutex představují, se zničí. Pojmenovaný mutex je zpočátku vlastněný prvním procesem. Druhý proces a všechny následné procesy počká, až dřívější procesy uvolní pojmenovaný mutex.

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

Poznámky

K name zadání oboru názvů může mít předponu Global\ nebo Local\ . Global Pokud je obor názvů zadaný, synchronizační objekt může být sdílen se všemi procesy v systému. Local Pokud je zadán obor názvů, což je také výchozí, pokud není zadán žádný obor názvů, synchronizační objekt může být sdílen s procesy ve stejné relaci. Ve Windows je relace přihlášení a služby obvykle běží v jiné neinteraktivní relaci. V unixových operačních systémech má každé prostředí svoji vlastní relaci. Objekty místní synchronizace relace mohou být vhodné pro synchronizaci mezi procesy se vztahem nadřazenosti a podřízenosti, kde se všechny spouští ve stejné relaci. Další informace o názvech synchronizačních objektů ve Windows najdete v tématu Názvy objektů.

name Pokud je zadán a objekt synchronizace požadovaného typu již existuje v oboru názvů, použije se existující synchronizační objekt. Pokud synchronizační objekt jiného typu již v oboru názvů existuje, WaitHandleCannotBeOpenedException vyvolá se objekt . V opačném případě se vytvoří nový synchronizační objekt.

Pokud name není null a initiallyOwned je true, volající vlákno vlastní pojmenovaný mutex pouze v případě, že createdNew je true po volání. V opačném případě může vlákno požadovat mutex voláním WaitOne metody .

Tento konstruktor inicializuje Mutex objekt, který představuje pojmenovaný system mutex. Můžete vytvořit více Mutex objektů, které představují stejný pojmenovaný system mutex.

Pokud byl pojmenovaný mutex již vytvořen se zabezpečením řízení přístupu a volající nemá MutexRights.FullControl práva, je vyvolána výjimka. Pokud chcete otevřít existující pojmenovaný mutex pouze s oprávněními potřebnými pro synchronizaci aktivit vláken, projděte si metodu OpenExisting .

Pokud zadáte null nebo prázdný řetězec pro name, vytvoří se místní mutex, jako byste volali Mutex(Boolean) konstruktor. V tomto případě createdNew je vždy true.

Vzhledem k tomu, že se jedná o celé systémy, je možné pojmenované mutexy použít ke koordinaci využití prostředků napříč hranicemi procesů.

Poznámka

Na serveru, na kterém běží Terminálová služba, může mít pojmenovaný systémový mutex dvě úrovně viditelnosti. Pokud jeho název začíná předponou Global\, je ve všech relacích terminálového serveru vidět mutex. Pokud jeho název začíná předponou Local\, je mutex viditelný pouze v relaci terminálového serveru, kde byl vytvořen. V takovém případě může v každé jiné relaci terminálového serveru na serveru existovat samostatný mutex se stejným názvem. Pokud při vytváření pojmenovaného mutex nezadáte předponu, převezme předponu Local\. V rámci relace terminálového serveru jsou dva mutexy, jejichž názvy se liší pouze předponami, samostatné mutexy a oba jsou viditelné všem procesům v relaci terminálového serveru. To znamená, že názvy Global\ předpon a Local\ popisují obor názvu mutex vzhledem k relacím terminálového serveru, nikoli vzhledem k procesům.

Upozornění

Ve výchozím nastavení není pojmenovaný mutex omezen na uživatele, který ho vytvořil. Ostatní uživatelé můžou být schopni otevřít a používat mutex, včetně toho, že mutex narušují vstupem do mutexu a neukončují ho. V unixových operačních systémech se systém souborů používá při implementaci pojmenovaných mutexů a jiní uživatelé mohou být schopni kolidovat s pojmenovanými mutexy významnějšími způsoby. Pokud chcete ve Windows omezit přístup na konkrétní uživatele, můžete při vytváření pojmenovaného mutex použít přetížení konstruktoru nebo MutexAcl předat MutexSecurity . V unixových operačních systémech v současné době neexistuje způsob, jak omezit přístup k pojmenovaným mutex. Vyhněte se používání pojmenovaných mutexů bez omezení přístupu k systémům, které můžou obsahovat nedůvěryhodné uživatele spouštěné kódem.

Zpětné lomítko (\) je vyhrazený znak v názvu mutex. Nepoužívejte zpětné lomítko (\) v názvu mutex, s výjimkou případů uvedených v poznámce o používání mutexů v relacích terminálového serveru. V opačném DirectoryNotFoundException případě může být vyvolán objekt , i když název objektu mutex představuje existující soubor.

Viz také

Platí pro

Mutex(Boolean, String, Boolean, MutexSecurity)

Inicializuje novou instanci Mutex třídy s logickou hodnotou, která označuje, zda volající vlákno má mít počáteční vlastnictví mutex, řetězec, který je názvem mutex, logická proměnná, která, když metoda vrátí, označuje, zda volající vlákno bylo uděleno počáteční vlastnictví mutex, a zabezpečení řízení přístupu, které se má použít na pojmenovaný mutex.

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)

Parametry

initiallyOwned
Boolean

truedát volající vlákno počáteční vlastnictví pojmenovaný system mutex pokud pojmenovaný system mutex je vytvořen jako výsledek tohoto volání; v opačném případě . false

name
String

Název, pokud synchronizační objekt má být sdílen s jinými procesy; null nebo prázdný řetězec. V názvu se rozlišují velká a malá písmena. Znak zpětného lomítka (\) je vyhrazený a lze ho použít pouze k určení oboru názvů. Další informace o oborech názvů najdete v části poznámky. V závislosti na operačním systému můžou existovat další omezení názvu. Například v unixových operačních systémech musí být název po vyloučení oboru názvů platný název souboru.

createdNew
Boolean

Když se tato metoda vrátí, obsahuje logickou hodnotu, která znamená true , že byl vytvořen místní mutex (tj. pokud name je null nebo prázdný řetězec) nebo byl vytvořen zadaný pojmenovaný systémový mutex; false pokud zadaný pojmenovaný systémový mutex již existoval. Tento parametr se předává neinicializovaný.

mutexSecurity
MutexSecurity

Objekt MutexSecurity , který představuje zabezpečení řízení přístupu, které má být použito na pojmenovaný system mutex.

Atributy

Výjimky

Formát name je neplatný. Může to být z různých důvodů, včetně některých omezení, která může operační systém použít, například kvůli neznámé předponě nebo neplatným znakům. Všimněte si, že názvy a běžné předpony Global a Local rozlišují malá a velká písmena.

-nebo-

Došlo k jiné chybě. Vlastnost HResult může poskytnout další informace.

Pouze windows: name zadal neznámý obor názvů. Další informace najdete v tématu Názvy objektů .

Je name příliš dlouhý. Omezení délky může záviset na operačním systému nebo konfiguraci.

Pojmenovaný mutex existuje a má zabezpečení řízení přístupu, ale uživatel nemá FullControl.

Synchronizační objekt se zadaným name objektem nelze vytvořit. Objekt synchronizace jiného typu může mít stejný název.

Pouze rozhraní .NET Framework: name je delší než MAX_PATH (260 znaků).

Příklady

Následující příklad kódu ukazuje chování mezi procesy pojmenovaného mutex se zabezpečením řízení přístupu. Příklad používá OpenExisting(String) přetížení metody k testování existence pojmenovaného mutex.

Pokud mutex neexistuje, vytvoří se s počátečním vlastnictvím a zabezpečením řízení přístupu, které aktuálnímu uživateli odepře právo používat mutex, ale uděluje oprávnění ke čtení a změnám oprávnění k mutexu.

Pokud zkompilovaný příklad spustíte ze dvou oken příkazů, druhá kopie vyvolá výjimku narušení přístupu při volání .OpenExisting(String) Výjimka je zachycena a příklad používá OpenExisting(String, MutexRights) přetížení metody k otevření mutexu s právy potřebnými ke čtení a změně oprávnění.

Po změně oprávnění se mutex otevře s právy potřebnými k jeho zadání a uvolnění. Pokud zkompilovaný příklad spustíte z třetího příkazového okna, spustí se s novými oprávněními.

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

Poznámky

K name zadání oboru názvů může mít předponu Global\ nebo Local\ . Global Pokud je obor názvů zadaný, synchronizační objekt může být sdílen se všemi procesy v systému. Local Pokud je zadán obor názvů, což je také výchozí, pokud není zadán žádný obor názvů, synchronizační objekt může být sdílen s procesy ve stejné relaci. Ve Windows je relace přihlášení a služby obvykle běží v jiné neinteraktivní relaci. V unixových operačních systémech má každé prostředí svoji vlastní relaci. Objekty místní synchronizace relace mohou být vhodné pro synchronizaci mezi procesy se vztahem nadřazenosti a podřízenosti, kde se všechny spouští ve stejné relaci. Další informace o názvech synchronizačních objektů ve Windows najdete v tématu Názvy objektů.

name Pokud je zadán a objekt synchronizace požadovaného typu již existuje v oboru názvů, použije se existující synchronizační objekt. Pokud synchronizační objekt jiného typu již v oboru názvů existuje, WaitHandleCannotBeOpenedException vyvolá se objekt . V opačném případě se vytvoří nový synchronizační objekt.

Pokud name není null a initiallyOwned je true, volající vlákno vlastní pojmenovaný mutex pouze v případě, že createdNew je true po volání. V opačném případě může vlákno požadovat mutex voláním WaitOne metody .

Pomocí tohoto konstruktoru můžete použít zabezpečení řízení přístupu na pojmenovaný systémový mutex při jeho vytvoření, což brání jinému kódu v převzetí řízení mutex.

Tento konstruktor inicializuje Mutex objekt, který představuje pojmenovaný system mutex. Můžete vytvořit více Mutex objektů, které představují stejný pojmenovaný system mutex.

Pokud pojmenovaný systémový mutex neexistuje, vytvoří se se zadaným zabezpečením řízení přístupu. Pokud pojmenovaný mutex existuje, zadané zabezpečení řízení přístupu se ignoruje.

Poznámka

Volající má plnou kontrolu nad nově vytvořeným Mutex objektem i v případě mutexSecurity , že aktuálnímu uživateli odmítne nebo neudělí některá přístupová práva. Pokud se však aktuální uživatel pokusí získat jiný Mutex objekt představující stejný pojmenovaný mutex pomocí konstruktoru OpenExisting nebo metody, použije se zabezpečení řízení přístupu systému Windows.

Pokud je pojmenovaný mutex již vytvořen se zabezpečením řízení přístupu a volající nemá MutexRights.FullControl, vyvolá se výjimka. Pokud chcete otevřít existující pojmenovaný mutex pouze s oprávněními potřebnými pro synchronizaci aktivit vláken, projděte si metodu OpenExisting .

Pokud zadáte null nebo prázdný řetězec pro name, vytvoří se místní mutex, jako byste volali Mutex(Boolean) konstruktor. V tomto případě createdNew je vždy true.

Vzhledem k tomu, že se jedná o celé systémy, je možné pojmenované mutexy použít ke koordinaci využití prostředků napříč hranicemi procesů.

Poznámka

Na serveru, na kterém běží Terminálová služba, může mít pojmenovaný systémový mutex dvě úrovně viditelnosti. Pokud jeho název začíná předponou Global\, je ve všech relacích terminálového serveru vidět mutex. Pokud jeho název začíná předponou Local\, je mutex viditelný pouze v relaci terminálového serveru, kde byl vytvořen. V takovém případě může v každé jiné relaci terminálového serveru na serveru existovat samostatný mutex se stejným názvem. Pokud při vytváření pojmenovaného mutex nezadáte předponu, převezme předponu Local\. V rámci relace terminálového serveru jsou dva mutexy, jejichž názvy se liší pouze předponami, samostatné mutexy a oba jsou viditelné všem procesům v relaci terminálového serveru. To znamená, že názvy Global\ předpon a Local\ popisují obor názvu mutex vzhledem k relacím terminálového serveru, nikoli vzhledem k procesům.

Upozornění

Ve výchozím nastavení není pojmenovaný mutex omezen na uživatele, který ho vytvořil. Ostatní uživatelé můžou být schopni otevřít a používat mutex, včetně toho, že mutex narušují vstupem do mutexu a neukončují ho. Pokud chcete omezit přístup na konkrétní uživatele, můžete při vytváření pojmenovaného mutex předat MutexSecurity . Vyhněte se používání pojmenovaných mutexů bez omezení přístupu k systémům, které můžou obsahovat nedůvěryhodné uživatele spouštěné kódem.

Zpětné lomítko (\) je vyhrazený znak v názvu mutex. Nepoužívejte zpětné lomítko (\) v názvu mutex, s výjimkou případů uvedených v poznámce o používání mutexů v relacích terminálového serveru. V opačném DirectoryNotFoundException případě může být vyvolán objekt , i když název objektu mutex představuje existující soubor.

Platí pro