Mutex Конструкторы

Определение

Пространство имен:

System.Threading

Сборка:

System.Threading.dll

Инициализирует новый экземпляр класса Mutex.

Перегрузки

Mutex()	Инициализирует новый экземпляр класса Mutex стандартными свойствами.
Mutex(Boolean)	Инициализирует новый экземпляр класса Mutex логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса.
Mutex(Boolean, String)	Инициализирует новый экземпляр класса Mutex логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, а также иметь строку, являющуюся именем мьютекса.
Mutex(Boolean, String, Boolean)	Инициализирует новый экземпляр класса Mutex логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, иметь строку, являющуюся именем мьютекса, и логическое значение, которое при возврате метода показывает, предоставлено ли вызывающему потоку изначальное владение мьютексом.

Mutex()

Исходный код:

Mutex.cs

Инициализирует новый экземпляр класса Mutex стандартными свойствами.

public:
 Mutex();

public Mutex ();

Public Sub New ()

Примеры

В следующем примере кода показано, как локальный Mutex объект используется для синхронизации доступа к защищенному ресурсу. Поток, создающий мьютекс, изначально не владеет им.

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

Комментарии

Вызов перегрузки конструктора совпадает с вызовом перегрузки Mutex(Boolean) конструктора и указанием false начального владения мьютексом. То есть вызывающий поток не является владельцем мьютекса.

См. также раздел

• Управляемая поточность
• Мьютексы

Mutex(Boolean)

Исходный код:

Mutex.cs

Инициализирует новый экземпляр класса Mutex логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса.

public:
 Mutex(bool initiallyOwned);

public Mutex (bool initiallyOwned);

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

Public Sub New (initiallyOwned As Boolean)

Параметры

initiallyOwned

Boolean

Значение true для предоставления вызывающему потоку изначального владения мьютексом; в противном случае — false.

Примеры

В следующем примере кода показано, как локальный Mutex объект используется для синхронизации доступа к защищенному ресурсу. Поток, создающий объект , Mutex изначально владеет им.

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

См. также раздел

• Управляемая поточность
• Мьютексы

Mutex(Boolean, String)

Исходный код:

Mutex.cs

Инициализирует новый экземпляр класса Mutex логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, а также иметь строку, являющуюся именем мьютекса.

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

public Mutex (bool initiallyOwned, string? name);

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

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

Параметры

initiallyOwned

Boolean

Значение true для предоставления вызывающему потоку изначального владения именованным системным мьютексом, если этот мьютекс создан данным вызовом; в противном случае — значение false.

name

String

Имя, если объект синхронизации должен использоваться совместно с другими процессами. В противном случае — null или пустая строка. Имя указано с учетом регистра. Символ обратной косой черты (\) зарезервирован и может использоваться только для указания пространства имен. Дополнительные сведения о пространствах имен см. в разделе примечаний. В зависимости от операционной системы могут существовать дополнительные ограничения на имя. Например, в операционных системах под управлением Unix имя после исключения пространства имен должно быть допустимым именем файла.

Исключения

UnauthorizedAccessException

Именованный мьютекс существует, имеет безопасность управления доступом, но пользователь не имеет прав FullControl.

IOException

name недопустим. Это исключение может возникнуть по разным причинам, включая некоторые ограничения, установленные операционной системой (например, в отношении использования неизвестных префиксов или недопустимых символов). Обратите внимание, что в имени и общих префиксах Global\" и "Local\" учитывается регистр.

- или -

Произошла другая ошибка. Дополнительные сведения можно получить с помощью свойства HResult.

DirectoryNotFoundException

Только в Windows. Для name указано неизвестное пространство имен. Дополнительные сведения см. в статье Имена объектов.

PathTooLongException

Слишком длинное значение name. Ограничения длины могут зависеть от операционной системы или конфигурации.

WaitHandleCannotBeOpenedException

Не удается создать объект синхронизации с указанным значением для параметра name. Возможно, другой объект синхронизации имеет такое же имя.

ArgumentException

Только в .NET Framework. name превышает значение MAX_PATH (260 символов).

Примеры

В следующем примере показано, как именованный мьютекс используется для передачи сигналов между потоками, выполняющихся в двух отдельных процессах.

Запустите эту программу из двух или более командных окон. Каждый процесс создает Mutex объект , представляющий именованный мьютекс MyMutex. Именованный мьютекс — это системный объект, время существования которого ограничивается временем существования Mutex объектов, представляющих его. Именованный мьютекс создается, когда первый процесс создает свой Mutex объект; в этом примере именованный мьютекс принадлежит первому процессу, который запускает программу. Именованный мьютекс уничтожается при освобождении 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

Комментарии

Может name иметь префикс Global\ или Local\ , чтобы указать пространство имен. Global Если указано пространство имен, объект синхронизации может быть совместно использоваться любым процессам в системе. При указании Local пространства имен, которое также используется по умолчанию, если пространство имен не указано, объект синхронизации может совместно использоваться процессами в одном сеансе. В Windows сеанс является сеансом входа, а службы обычно выполняются в другом неинтерактивном сеансе. В unix-подобных операционных системах каждая оболочка имеет собственный сеанс. Объекты локальной синхронизации сеанса могут подходить для синхронизации между процессами с отношением "родители-потомки", где все они выполняются в одном сеансе. Дополнительные сведения об именах объектов синхронизации в Windows см. в разделе Имена объектов.

name Если предоставляется и объект синхронизации запрошенного типа уже существует в пространстве имен, используется существующий объект синхронизации. Если объект синхронизации другого типа уже существует в пространстве имен, WaitHandleCannotBeOpenedException возникает исключение . В противном случае создается новый объект синхронизации.

Если name имеет значение не null и initiallyOwned имеет значение true, вызывающий поток владеет мьютексом только в том случае, если в результате этого вызова был создан именованный системный мьютекс. Так как механизм для определения того, был ли создан именованный системный мьютекс, лучше указать false для initiallyOwned при вызове перегрузки конструктора. Конструктор можно использовать, Mutex(Boolean, String, Boolean) если необходимо определить начальное владение.

Этот конструктор инициализирует Mutex объект , представляющий именованный системный мьютекс. Можно создать несколько Mutex объектов, представляющих один и тот же именованный системный мьютекс.

Если именованный мьютекс уже создан с безопасностью управления доступом, а у MutexRights.FullControlвызывающего объекта нет , создается исключение. Чтобы открыть существующий именованный мьютекс только с разрешениями, необходимыми для синхронизации действий потоков, см OpenExisting . метод .

Если указать null или пустую строку для name, создается локальный мьютекс, как если бы вы вызвали Mutex(Boolean) конструктор. В этом случае createdNew всегда trueимеет значение .

Так как они являются системными, именованные мьютексы можно использовать для координации использования ресурсов в пределах процесса.

Примечание

На сервере со службами терминалов именованный системный мьютекс может иметь два уровня видимости. Если имя начинается с префикса Global\, мьютекс отображается во всех сеансах сервера терминалов. Если его имя начинается с префикса Local\, мьютекс отображается только в сеансе сервера терминалов, где он был создан. В этом случае в каждом сеансе сервера терминалов на сервере может существовать отдельный мьютекс с одинаковым именем. Если префикс не указан при создании именованного мьютекса, он принимает префикс Local\. В сеансе сервера терминалов два мьютекса, имена которых отличаются только префиксами, являются отдельными мьютексами и видны всем процессам в сеансе сервера терминалов. То есть имена префиксов Global\ и Local\ описывают область имени мьютекса относительно сеансов сервера терминалов, а не относительно процессов.

Внимание!

По умолчанию именованный мьютекс не ограничивается пользователем, который его создал. Другие пользователи могут открыть и использовать мьютекс, в том числе вмешиваться в мьютекс, введя мьютекс и не выходя из него. В unix-подобных операционных системах файловая система используется в реализации именованных мьютексов, и другие пользователи могут более значительным образом вмешиваться в именованные мьютексы. В Windows, чтобы ограничить доступ для определенных пользователей, можно использовать перегрузку конструктора или MutexAcl передать в MutexSecurity при создании именованного мьютекса. В операционных системах, подобных Unix, в настоящее время невозможно ограничить доступ к именованному мьютексу. Избегайте использования именованных мьютексов без ограничений доступа в системах, в которых код могут выполнять ненадежные пользователи.

Обратная косая черта (\) — это зарезервированный символ в имени мьютекса. Не используйте обратную косую черту (\) в имени мьютекса, за исключением случаев, указанных в примечании об использовании мьютексов в сеансах сервера терминалов. В противном случае может возникнуть исключение DirectoryNotFoundException, даже если имя мьютекса представляет существующий файл.

См. также раздел

• Управляемая поточность
• Мьютексы

Mutex(Boolean, String, Boolean)

Исходный код:

Mutex.cs

Инициализирует новый экземпляр класса Mutex логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, иметь строку, являющуюся именем мьютекса, и логическое значение, которое при возврате метода показывает, предоставлено ли вызывающему потоку изначальное владение мьютексом.

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

public Mutex (bool initiallyOwned, string? name, out bool createdNew);

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

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

Параметры

initiallyOwned

Boolean

Значение true для предоставления вызывающему потоку изначального владения именованным системным мьютексом, если этот мьютекс создан данным вызовом; в противном случае — значение false.

name

String

Имя, если объект синхронизации должен использоваться совместно с другими процессами. В противном случае — null или пустая строка. Имя указано с учетом регистра. Символ обратной косой черты (\) зарезервирован и может использоваться только для указания пространства имен. Дополнительные сведения о пространствах имен см. в разделе примечаний. В зависимости от операционной системы могут быть дополнительные ограничения на имя. Например, в операционных системах под управлением Unix имя после исключения пространства имен должно быть допустимым именем файла.

createdNew

Boolean

При возврате из метода содержит логическое значение true, если был создан локальный мьютекс (то есть, если параметр name имеет значение null или содержит пустую строку) или был создан именованный системный мьютекс; значение false, если указанный именованный системный мьютекс уже существует. Этот параметр передается неинициализированным.

Исключения

UnauthorizedAccessException

Именованный мьютекс существует, имеет безопасность управления доступом, но пользователь не имеет прав FullControl.

IOException

name недопустим. Это исключение может возникнуть по разным причинам, включая некоторые ограничения, установленные операционной системой (например, в отношении использования неизвестных префиксов или недопустимых символов). Обратите внимание, что в имени и общих префиксах Global\" и "Local\" учитывается регистр.

- или -

Произошла другая ошибка. Дополнительные сведения можно получить с помощью свойства HResult.

DirectoryNotFoundException

Только в Windows. Для name указано неизвестное пространство имен. Дополнительные сведения см. в статье Имена объектов.

PathTooLongException

Слишком длинное значение name. Ограничения длины могут зависеть от операционной системы или конфигурации.

WaitHandleCannotBeOpenedException

Не удается создать объект синхронизации с указанным значением для параметра name. Возможно, другой объект синхронизации имеет такое же имя.

ArgumentException

Только в .NET Framework. name превышает значение MAX_PATH (260 символов).

Примеры

В следующем примере кода показано, как именованный мьютекс используется для передачи сигналов между процессами или потоками. Запустите эту программу из двух или более командных окон. Каждый процесс создает Mutex объект , представляющий именованный мьютекс MyMutex. Именованный мьютекс является системным объектом. В этом примере его время существования ограничивается временем существования Mutex объектов, которые его представляют. Именованный мьютекс создается, когда первый процесс создает свой локальный Mutex объект, и уничтожается при освобождении всех 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

Комментарии

Для name указания пространства имен может быть задан Global\ префикс или Local\ . При указании Global пространства имен объект синхронизации может использоваться совместно с любыми процессами в системе. При указании Local пространства имен, которое также используется по умолчанию, если пространство имен не указано, объект синхронизации может быть совместно использоваться процессами в одном сеансе. В Windows сеанс является сеансом входа, а службы обычно выполняются в другом неинтерактивном сеансе. В операционных системах, подобных Unix, каждая оболочка имеет собственный сеанс. Объекты локальной синхронизации сеанса могут быть подходящими для синхронизации между процессами с отношением "родитель-потомок", где все они выполняются в одном сеансе. Дополнительные сведения об именах объектов синхронизации в Windows см. в разделе Имена объектов.

name Если предоставляется и объект синхронизации запрошенного типа уже существует в пространстве имен, используется существующий объект синхронизации. Если объект синхронизации другого типа уже существует в пространстве имен, WaitHandleCannotBeOpenedException возникает исключение . В противном случае создается новый объект синхронизации.

Если name параметр не null имеет и initiallyOwned имеет значение true, вызывающий поток владеет именованным мьютексом только в том случае, если createdNew находится true после вызова. В противном случае поток может запросить мьютекс, вызвав WaitOne метод .

Этот конструктор инициализирует Mutex объект , представляющий именованный системный мьютекс. Можно создать несколько Mutex объектов, представляющих один и тот же именованный системный мьютекс.

Если именованный мьютекс уже создан с безопасностью управления доступом, а вызывающий объект не имеет MutexRights.FullControl прав, создается исключение. Чтобы открыть существующий именованный мьютекс с разрешениями, необходимыми для синхронизации действий потоков, см OpenExisting . метод .

Если указать null или пустую строку для name, создается локальный мьютекс, как если бы вы вызвали Mutex(Boolean) конструктор. В этом случае createdNew всегда trueимеет значение .

Так как они являются системными, именованные мьютексы можно использовать для координации использования ресурсов через границы процесса.

Примечание

На сервере, на котором выполняются службы терминалов, именованный системный мьютекс может иметь два уровня видимости. Если его имя начинается с префикса Global\, мьютекс отображается во всех сеансах сервера терминалов. Если его имя начинается с префикса Local\, мьютекс отображается только в сеансе сервера терминалов, где он был создан. В этом случае в каждом из других сеансов сервера терминалов на сервере может существовать отдельный мьютекс с тем же именем. Если префикс не указан при создании именованного мьютекса, он принимает префикс Local\. В сеансе сервера терминалов два мьютекса, имена которых отличаются только префиксами, являются отдельными мьютексами и видны всем процессам в сеансе сервера терминалов. Это значит, что префиксные имена Global\ и Local\ описывают область имени мьютекса относительно сеансов сервера терминалов, а не относительно процессов.

Внимание!

По умолчанию именованный мьютекс не ограничивается пользователем, который его создал. Другие пользователи могут открывать и использовать мьютекс, в том числе вмешиваться в мьютекс, вводя мьютекс и не выходя из него. В unix-подобных операционных системах файловая система используется в реализации именованных мьютексов, и другие пользователи могут более существенно вмешиваться в именованные мьютексы. В Windows, чтобы ограничить доступ для определенных пользователей, можно использовать перегрузку конструктора или MutexAcl передать MutexSecurity в при создании именованного мьютекса. В операционных системах, подобных Unix, в настоящее время невозможно ограничить доступ к именованному мьютексу. Избегайте использования именованных мьютексов без ограничений доступа в системах, в которых могут выполняться ненадежные пользователи, выполняющие код.

Обратная косая черта (\) является зарезервированным символом в имени мьютекса. Не используйте обратную косую черту (\) в имени мьютекса, за исключением случаев, указанных в примечании об использовании мьютексов в сеансах сервера терминалов. В противном случае может возникнуть исключение DirectoryNotFoundException, даже если имя мьютекса представляет существующий файл.

См. также раздел

• Управляемая поточность
• Мьютексы