Mutex Construtores

Definição

Namespace:

System.Threading

Assembly:

System.Threading.dll

Inicializa uma nova instância da classe Mutex.

Sobrecargas

Mutex()	Inicializa uma nova instância da classe Mutex com propriedades padrão.
Mutex(Boolean)	Inicializa uma nova instância da classe Mutex com um valor booliano que indica se o thread de chamada deve ter a propriedade inicial do mutex.
Mutex(Boolean, String)	Inicializa uma nova instância da classe Mutex com um valor booliano que indica se o thread de chamada deve ter uma propriedade inicial do mutex e uma cadeia de caracteres que é o nome do mutex.
Mutex(Boolean, String, Boolean)	Inicializa uma nova instância da classe Mutex com um valor booliano que indica se o thread de chamada deve ter a propriedade inicial de mutex, uma cadeia de caracteres que é o nome do mutex e um valor booliano que, quando o método retorna, indica se o thread de chamada foi concedido a propriedade inicial do mutex.

Mutex()

Origem:

Mutex.cs

Inicializa uma nova instância da classe Mutex com propriedades padrão.

public:
 Mutex();

public Mutex ();

Public Sub New ()

Exemplos

O exemplo de código a seguir mostra como um objeto local Mutex é usado para sincronizar o acesso a um recurso protegido. O thread que cria o mutex não o possui inicialmente.

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

Comentários

Chamar essa sobrecarga de construtor é o mesmo que chamar a sobrecarga do Mutex(Boolean) construtor e especificar false a propriedade inicial do mutex. Ou seja, o thread de chamada não possui o mutex.

Confira também

• Threading gerenciado
• Mutexes

Mutex(Boolean)

Origem:

Mutex.cs

Inicializa uma nova instância da classe Mutex com um valor booliano que indica se o thread de chamada deve ter a propriedade inicial do mutex.

public:
 Mutex(bool initiallyOwned);

public Mutex (bool initiallyOwned);

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

Public Sub New (initiallyOwned As Boolean)

Parâmetros

initiallyOwned

Boolean

true para dar ao thread de chamada propriedade inicial do mutex; caso contrário, false.

Exemplos

O exemplo de código a seguir mostra como um objeto local Mutex é usado para sincronizar o acesso a um recurso protegido. O thread que cria o Mutex possui inicialmente.

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

Confira também

• Threading gerenciado
• Mutexes

Mutex(Boolean, String)

Origem:

Mutex.cs

Inicializa uma nova instância da classe Mutex com um valor booliano que indica se o thread de chamada deve ter uma propriedade inicial do mutex e uma cadeia de caracteres que é o nome do 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)

Parâmetros

initiallyOwned

Boolean

true para dar ao thread de chamada a propriedade inicial do mutex do sistema nomeado se o mutex nomeado sistema foi criado como resultado dessa chamada; caso contrário, false.

name

String

O nome, se o objeto de sincronização deve ser compartilhado com outros processos; caso contrário, null ou uma cadeia de caracteres vazia. O nome diferencia maiúsculas de minúsculas. O caractere de barra invertida (\) é reservado e só pode ser usado para especificar um namespace. Para obter mais informações sobre namespaces, consulte a seção comentários. Pode haver mais restrições sobre o nome, dependendo do sistema operacional. Por exemplo, em sistemas operacionais baseados em Unix, o nome após a exclusão do namespace deve ser um nome de arquivo válido.

Exceções

UnauthorizedAccessException

O mutex nomeado existe e tem segurança de controle de acesso, mas o usuário não tem FullControl.

IOException

name é inválido. Isso pode ser por vários motivos, incluindo algumas restrições impostas pelo sistema operacional, como um prefixo desconhecido ou caracteres inválidos. Observe que o nome e os prefixos comuns "Global\" e "Local\" diferenciam maiúsculas de minúsculas.

- ou -

Ocorreu outro erro. A propriedade HResult pode fornecer mais informações.

DirectoryNotFoundException

Somente Windows: name especificou um namespace desconhecido. Confira mais informações em Nomes do objeto.

PathTooLongException

O name é muito longo. As restrições de comprimento podem depender do sistema operacional ou da configuração.

WaitHandleCannotBeOpenedException

Não é possível criar um objeto de sincronização com o name fornecido. Um objeto de sincronização de um tipo diferente pode ter o mesmo nome.

ArgumentException

Somente .NET Framework: name é maior que MAX_PATH (260 caracteres).

Exemplos

O exemplo a seguir mostra como um mutex nomeado é usado para sinalizar entre threads em execução em dois processos separados.

Execute este programa em duas ou mais janelas de comando. Cada processo cria um Mutex objeto que representa o mutex MyMutexnomeado. O mutex nomeado é um objeto do sistema cujo tempo de vida é limitado pelos tempos de vida dos objetos que o Mutex representam. O mutex nomeado é criado quando o primeiro processo cria seu Mutex objeto; neste exemplo, o mutex nomeado pertence ao primeiro processo que executa o programa. O mutex nomeado é destruído quando todos os objetos que o Mutex representam são liberados.

A sobrecarga do construtor usada neste exemplo não pode informar ao thread de chamada se a propriedade inicial do mutex nomeado foi concedida. Você não deve usar esse construtor para solicitar a propriedade inicial, a menos que possa ter certeza de que o thread criará o mutex nomeado.

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

Comentários

O name pode ser prefixado com Global\ ou Local\ para especificar um namespace. Quando o Global namespace é especificado, o objeto de sincronização pode ser compartilhado com todos os processos no sistema. Quando o Local namespace é especificado, que também é o padrão quando nenhum namespace é especificado, o objeto de sincronização pode ser compartilhado com processos na mesma sessão. No Windows, uma sessão é uma sessão de logon e os serviços normalmente são executados em uma sessão não interativa diferente. Em sistemas operacionais semelhantes ao Unix, cada shell tem sua própria sessão. Os objetos de sincronização local de sessão podem ser apropriados para sincronizar entre processos com uma relação pai/filho em que todos eles são executados na mesma sessão. Para obter mais informações sobre nomes de objetos de sincronização no Windows, consulte Nomes de objetos.

Se um name for fornecido e um objeto de sincronização do tipo solicitado já existir no namespace, o objeto de sincronização existente será usado. Se um objeto de sincronização de um tipo diferente já existir no namespace, um WaitHandleCannotBeOpenedException será gerado. Caso contrário, um novo objeto de sincronização será criado.

Se name não null for e initiallyOwned for true, o thread de chamada será proprietário do mutex somente se o mutex do sistema nomeado tiver sido criado como resultado dessa chamada. Como não há mecanismo para determinar se o mutex do sistema nomeado foi criado, é melhor especificar false para initiallyOwned ao chamar essa sobrecarga de construtor. Você pode usar o Mutex(Boolean, String, Boolean) construtor se precisar determinar a propriedade inicial.

Esse construtor inicializa um Mutex objeto que representa um mutex do sistema nomeado. Você pode criar vários Mutex objetos que representam o mesmo mutex de sistema nomeado.

Se o mutex nomeado já tiver sido criado com segurança de controle de acesso e o chamador não tiver MutexRights.FullControl, uma exceção será gerada. Para abrir um mutex nomeado existente com apenas as permissões necessárias para sincronizar atividades de thread, consulte o OpenExisting método .

Se você especificar null ou uma cadeia de caracteres vazia para name, um mutex local será criado, como se você tivesse chamado o Mutex(Boolean) construtor. Nesse caso, createdNew é sempre true.

Como eles são de todo o sistema, os mutexes nomeados podem ser usados para coordenar o uso de recursos entre os limites do processo.

Observação

Em um servidor que está executando os Serviços de Terminal, um mutex de sistema nomeado pode ter dois níveis de visibilidade. Se seu nome começar com o prefixo Global\, o mutex ficará visível em todas as sessões de servidor de terminal. Se seu nome começar com o prefixo Local\, o mutex ficará visível somente na sessão do servidor do terminal em que foi criado. Nesse caso, um mutex separado com o mesmo nome pode existir em cada uma das outras sessões de servidor de terminal no servidor. Se você não especificar um prefixo ao criar um mutex nomeado, ele usará o prefixo Local\. Em uma sessão de servidor de terminal, dois mutexes cujos nomes diferem apenas por seus prefixos são mutexes separados e ambos são visíveis para todos os processos na sessão do servidor terminal. Ou seja, os nomes Global\ de prefixo e Local\ descrevem o escopo do nome mutex em relação às sessões do servidor de terminal, não em relação aos processos.

Cuidado

Por padrão, um mutex nomeado não é restrito ao usuário que o criou. Outros usuários podem ser capazes de abrir e usar o mutex, incluindo interferir no mutex inserindo o mutex e não saindo dele. Em sistemas operacionais semelhantes ao Unix, o sistema de arquivos é usado na implementação de mutexes nomeados e outros usuários podem interferir em mutexes nomeados de maneiras mais significativas. No Windows, para restringir o acesso a usuários específicos, você pode usar uma sobrecarga de construtor ou MutexAcl e passar um MutexSecurity ao criar o mutex nomeado. Em sistemas operacionais semelhantes ao Unix, atualmente não há como restringir o acesso a um mutex nomeado. Evite usar mutexes nomeados sem restrições de acesso em sistemas que podem ter usuários não confiáveis executando código.

A barra invertida (\) é um caractere reservado em um nome mutex. Não use uma barra invertida (\) em um nome mutex, exceto conforme especificado na anotação sobre como usar mutexes em sessões de servidor de terminal. Caso contrário, uma DirectoryNotFoundException pode ser gerada, mesmo que o nome do mutex represente um arquivo existente.

Confira também

• Threading gerenciado
• Mutexes

Mutex(Boolean, String, Boolean)

Origem:

Mutex.cs

Inicializa uma nova instância da classe Mutex com um valor booliano que indica se o thread de chamada deve ter a propriedade inicial de mutex, uma cadeia de caracteres que é o nome do mutex e um valor booliano que, quando o método retorna, indica se o thread de chamada foi concedido a propriedade inicial do 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)

Parâmetros

initiallyOwned

Boolean

true para dar ao thread de chamada a propriedade inicial do mutex do sistema nomeado se o mutex nomeado sistema foi criado como resultado dessa chamada; caso contrário, false.

name

String

O nome, se o objeto de sincronização deve ser compartilhado com outros processos; caso contrário, null ou uma cadeia de caracteres vazia. O nome diferencia maiúsculas de minúsculas. O caractere de barra invertida (\) é reservado e só pode ser usado para especificar um namespace. Para obter mais informações sobre namespaces, consulte a seção comentários. Pode haver mais restrições sobre o nome, dependendo do sistema operacional. Por exemplo, em sistemas operacionais baseados em Unix, o nome após a exclusão do namespace deve ser um nome de arquivo válido.

createdNew

Boolean

Quando este método retorna, contém um valor booliano que é true se um mutex local foi criado (ou seja, se name é null ou uma cadeia de caracteres vazia) ou se o mutex do sistema nomeado especificado foi criado; false se o mutex do sistema nomeado já existia. Este parâmetro é passado não inicializado.

Exceções

UnauthorizedAccessException

O mutex nomeado existe e tem segurança de controle de acesso, mas o usuário não tem FullControl.

IOException

name é inválido. Isso pode ser por vários motivos, incluindo algumas restrições impostas pelo sistema operacional, como um prefixo desconhecido ou caracteres inválidos. Observe que o nome e os prefixos comuns "Global\" e "Local\" diferenciam maiúsculas de minúsculas.

- ou -

Ocorreu outro erro. A propriedade HResult pode fornecer mais informações.

DirectoryNotFoundException

Somente Windows: name especificou um namespace desconhecido. Confira mais informações em Nomes do objeto.

PathTooLongException

O name é muito longo. As restrições de comprimento podem depender do sistema operacional ou da configuração.

WaitHandleCannotBeOpenedException

Não é possível criar um objeto de sincronização com o name fornecido. Um objeto de sincronização de um tipo diferente pode ter o mesmo nome.

ArgumentException

Somente .NET Framework: name é maior que MAX_PATH (260 caracteres).

Exemplos

O exemplo de código a seguir mostra como um mutex nomeado é usado para sinalizar entre processos ou threads. Execute este programa em duas ou mais janelas de comando. Cada processo cria um Mutex objeto que representa o mutex nomeado "MyMutex". O mutex nomeado é um objeto do sistema. Neste exemplo, seu tempo de vida é limitado pelos tempos de vida dos objetos que o Mutex representam. O mutex nomeado é criado quando o primeiro processo cria seu objeto local Mutex e destruído quando todos os objetos que o Mutex representam foram liberados. O mutex nomeado pertence inicialmente ao primeiro processo. O segundo processo e todos os processos subsequentes esperam que os processos anteriores liberem o mutex nomeado.

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

Comentários

O name pode ser prefixado com Global\ ou Local\ para especificar um namespace. Quando o Global namespace é especificado, o objeto de sincronização pode ser compartilhado com todos os processos no sistema. Quando o Local namespace é especificado, que também é o padrão quando nenhum namespace é especificado, o objeto de sincronização pode ser compartilhado com processos na mesma sessão. No Windows, uma sessão é uma sessão de logon e os serviços normalmente são executados em uma sessão não interativa diferente. Em sistemas operacionais semelhantes ao Unix, cada shell tem sua própria sessão. Objetos de sincronização local de sessão podem ser apropriados para sincronização entre processos com uma relação pai/filho em que todos eles são executados na mesma sessão. Para obter mais informações sobre nomes de objetos de sincronização no Windows, consulte Nomes de objeto.

Se um name for fornecido e um objeto de sincronização do tipo solicitado já existir no namespace , o objeto de sincronização existente será usado. Se um objeto de sincronização de um tipo diferente já existir no namespace , um WaitHandleCannotBeOpenedException será gerado. Caso contrário, um novo objeto de sincronização será criado.

Se name não null for e initiallyOwned for true, o thread de chamada será proprietário do mutex nomeado somente se createdNew estiver true após a chamada. Caso contrário, o thread poderá solicitar o mutex chamando o WaitOne método .

Esse construtor inicializa um Mutex objeto que representa um mutex do sistema nomeado. Você pode criar vários Mutex objetos que representam o mesmo mutex do sistema nomeado.

Se o mutex nomeado já tiver sido criado com segurança de controle de acesso e o chamador não tiver MutexRights.FullControl direitos, uma exceção será gerada. Para abrir um mutex nomeado existente com apenas as permissões necessárias para sincronizar atividades de thread, consulte o OpenExisting método .

Se você especificar null ou uma cadeia de caracteres vazia para name, um mutex local será criado, como se você tivesse chamado o Mutex(Boolean) construtor. Nesse caso, createdNew é sempre true.

Como eles são em todo o sistema, mutexes nomeados podem ser usados para coordenar o uso de recursos entre limites de processo.

Observação

Em um servidor que está executando os Serviços de Terminal, um mutex de sistema nomeado pode ter dois níveis de visibilidade. Se seu nome começar com o prefixo Global\, o mutex ficará visível em todas as sessões de servidor de terminal. Se seu nome começar com o prefixo Local\, o mutex ficará visível somente na sessão do servidor de terminal em que foi criado. Nesse caso, um mutex separado com o mesmo nome pode existir em cada uma das outras sessões de servidor de terminal no servidor. Se você não especificar um prefixo ao criar um mutex nomeado, ele usará o prefixo Local\. Em uma sessão de servidor de terminal, dois mutexes cujos nomes diferem apenas por seus prefixos são mutexes separados e ambos são visíveis para todos os processos na sessão do servidor terminal. Ou seja, os nomes Global\ de prefixo e Local\ descrevem o escopo do nome mutex em relação às sessões do servidor de terminal, não em relação aos processos.

Cuidado

Por padrão, um mutex nomeado não é restrito ao usuário que o criou. Outros usuários podem ser capazes de abrir e usar o mutex, incluindo interferir no mutex inserindo o mutex e não saindo dele. Em sistemas operacionais semelhantes ao Unix, o sistema de arquivos é usado na implementação de mutexes nomeados e outros usuários podem interferir em mutexes nomeados de maneiras mais significativas. No Windows, para restringir o acesso a usuários específicos, você pode usar uma sobrecarga de construtor ou MutexAcl e passar um MutexSecurity ao criar o mutex nomeado. Em sistemas operacionais semelhantes ao Unix, atualmente não há como restringir o acesso a um mutex nomeado. Evite usar mutexes nomeados sem restrições de acesso em sistemas que podem ter usuários não confiáveis executando código.

A barra invertida (\) é um caractere reservado em um nome mutex. Não use uma barra invertida (\) em um nome mutex, exceto conforme especificado na anotação sobre como usar mutexes em sessões de servidor de terminal. Caso contrário, uma DirectoryNotFoundException pode ser gerada, mesmo que o nome do mutex represente um arquivo existente.

Confira também

• Threading gerenciado
• Mutexes