Mutex Objects

9/8/2008

Um objeto mutex é um objeto sincronização cujo estado é definido como sinalizado quando ele não pertence por um segmento.

Como seu nome diz, ele acessar mutuamente coordenadas a um recurso compartilhado.

Somente um segmento em um tempo pode possuir um objeto mutex.

Um segmento chama a função CreateMutex para criar um objeto mutex. O criação de segmento pode apropriar imediata solicitação do objeto mutex, como bem como especificar um nome para o objeto mutex.

Segmentos em outros processos podem aberto um identificador para um objeto mutex existente, especificando o nome objeto em um chamar para CreateMutex. Se um objeto mutex com esse nome já existir, GetLastError retornará ERROR_ALREADY_EXISTS.

Para obter mais informações sobre nomes de objetos mutex e objetos evento, consulte Interprocess Synchronization.

Qualquer segmento com um identificador para um objeto mutex pode usar uma função de espera para a propriedade solicitação do objeto mutex.

Se o objeto mutex é de propriedade outro segmento, a função de espera bloqueia o segmento solicitante até que o segmento proprietário libera o objeto mutex por chamado a função ReleaseMutex.

O valor de retorno da função de espera indica se a função retornados por algum motivo diferente que o estado do mutex está definido para sinalizado.

Para obter mais informações sobre funções de espera, consulte Wait Functions.

Quando um segmento possui um objeto mutex, ele pode especificar o mutex mesmo objeto em Chamadas repetidas para uma das funções de espera sem bloqueio-lo. Isso impede que um segmento de deadlocking próprio enquanto espera para um objeto mutex que ele já possui.

A versão sua propriedade tais circunstâncias, o segmento deve chamar ReleaseMutex Uma vez para cada tempo que o objeto mutex atendidas as condições de uma função de espera.

Um objeto mutex é considerado abandonado se um segmento é encerrado sem liberar a sua posse de um objeto mutex.

Um segmento em espera poderá adquirir propriedade de um objeto mutex abandonadas, mas o valor de retorno função de espera indica que o objeto mutex é abandonado.

Para ser seguro, suponha que um objeto mutex abandonadas indica que ocorreu um erro e que qualquer recurso compartilhado protegidos pelo objeto mutex está em um indefinido estado.

Se o segmento continuará, embora o objeto mutex não é abandonado, sinalizador abandonadas do objeto será limpo quando o segmento libera a sua posse. Isso restaura o comportamento típico se um identificador para o objeto mutex subseqüentemente for especificado em uma função de espera.

O seguinte exemplo de código mostra como chamar CreateMutex Para criar um nomeado objeto mutex:

void NamedMutexExample (void)
{
   HANDLE  hMutex;
   TCHAR szMsg[100];
   hMutex = CreateMutex (NULL, // No security descriptor
                         FALSE, // Mutex object not owned
                         TEXT("NameOfMutexObject")); // Object name
      if (NULL == hMutex)
         {
            // Your code to deal with the error goes here.
            // Here is one example of what might be done.
            wsprintf (szMsg, TEXT("CreateMutex error: %d."), GetLastError ());
            MessageBox (NULL, szMsg, TEXT("Error"), MB_OK);
         }
      else
         {
            // Not an error: deal with success
            if ( ERROR_ALREADY_EXISTS == GetLastError () )
               MessageBox (NULL, TEXT("CreateMutex opened existing mutex."), TEXT("Results"), MB_OK);
           else
              MessageBox (NULL, TEXT("CreateMutex created new mutex."), TEXT("Results"), MB_OK);
         }
      }
   }
}

O seguinte exemplo de código abre um identificador de um objeto mutex. Ele também usa Tente-Finalmente exceção estruturada-sintaxe manipulação para garantir que o segmento corretamente libera o objeto mutex.

Para evitar o objeto mutex do que está sendo abandonada inadvertidamente, o Finalmente bloco de codificar executado independentemente como o Tente bloco termina, a menos que o Tente bloco inclui um chamar a função de TerminateThread.

BOOL WriteToDatabase (HANDLE hMutex)
{
   DWORD dwWaitResult;
   dwWaitResult = WaitForSingleObject (hMutex, // Handle of mutex object
   5000L); // Five-second time-out
   switch (dwWaitResult)
   {
      case WAIT_OBJECT_0:
      __try
      {
         // Your code to write to the database goes here.
      }
   __finally
      {
         // Your code to clean up the database operations goes here.
         if (! ReleaseMutex (hMutex))
            {
               // Your code to deal with the error goes here.
            }
         }
      break;
      // Cannot get mutex object ownership due to time-out
      case WAIT_TIMEOUT:
      return FALSE;
      // Got ownership of an abandoned mutex object
      case WAIT_ABANDONED:
      return FALSE;
   }
   return TRUE;
}

See Also

Concepts

Synchronization