O que é um mutex?

Quando estou a ter uma grande discussão no trabalho, uso uma galinha de borracha que guardo na minha secretária para ocasiões como esta. A pessoa que tem a galinha é a única pessoa autorizada a falar. Se não segurar na galinha, não pode falar. Só pode indicar que quer a galinha e esperar até a receber antes de falar. Depois de ter terminado de falar, você pode entregar o frango de volta para o moderador que vai entregá-lo para a próxima pessoa a falar. Isto garante que as pessoas não falam umas sobre as outras, e também têm o seu próprio espaço para falar. Substitua galinha por Mutex e pessoa por linha e basicamente tem o conceito de mutex. É claro que um mutex de borracha não existe. Só frango de borracha. Os meus gatos já tiveram um rato de borracha, mas comeram-no. É claro que, antes de usar o frango de borracha, tem de se perguntar se precisa de 5 pessoas numa sala e se não seria mais fácil com uma pessoa. no quarto por conta própria a fazer o trabalho todo. Na verdade, isto é apenas uma extensão da analogia, mas você entende a ideia.

Um Mutex é uma bandeira mutuamente exclusiva. Ele atua como um guardião do portal para uma seção de código permitindo um fio dentro e bloqueando o acesso a todos os outros. Isto garante que o código a ser controlado só será atingido por um único fio de cada vez. Certifica-te de libertar o mutex quando acabares. :)

Exclusão Mútua. Aqui está o item da Wikipédia:

Http://en.wikipedia.org/wiki/Mutual_exclusion

O ponto de um mutex é sincronizar duas threads. Quando você tem dois threads tentando acessar um único recurso, o padrão geral é ter o primeiro bloco de código tentando acessar para definir o mutex antes de entrar no código. Quando o segundo bloco de código tenta acesso, ele vê o mutex é definido e espera até que o primeiro bloco de código esteja completo (e des-define o mutex), então continua.

Os detalhes específicos de como isto é realizado obviamente varia muito por linguagem de programação.

Quando você tem uma aplicação multi-roscada, os diferentes tópicos às vezes compartilham um recurso comum, como uma variável ou similar. Esta fonte compartilhada muitas vezes não pode ser acessada ao mesmo tempo, então uma construção é necessária para garantir que apenas um thread está usando esse recurso de cada vez.

O conceito é chamado de "exclusão mútua" (Mutex curto), e é uma maneira de garantir que apenas um fio é permitido dentro dessa área, usando esse recurso, etc.

Como usá-los é linguagem específica, mas é muitas vezes (se não sempre) baseado em um sistema operativo mutex.

Algumas linguagens não precisam desta construção, devido ao paradigma, por exemplo, programação funcional (Haskell, ML são bons exemplos).

Agora, vá perguntar ao google como usá-los! :)

Em C#, o mutex comum utilizado é oMonitor . O tipo é ' Sistema.Roscar.Monitor ". Também pode ser usado implicitamente através da instrução 'lock(Object)'. Um exemplo de seu uso é quando se constrói uma classe Singleton.

private static readonly Object instanceLock = new Object();
private static MySingleton instance;
public static MySingleton Instance
{
    lock(instanceLock)
    {
        if(instance == null)
        {
            instance = new MySingleton();
        }
        return instance;
    }
}

A declaração de bloqueio com o objecto de bloqueio privado cria uma secção crítica. Exigindo que cada tópico espere até que o anterior esteja terminado. O primeiro tópico irá entrar na secção e inicializar a instância. O segundo tópico vou esperar, entrar na secção, e obter a instância inicializada.

Qualquer tipo de sincronização de um membro estático pode usar a declaração de bloqueio da mesma forma.

Para entender o MUTEX no início você precisa saber o que é" condição de raça " e então só você vai entender por que o MUTEX é necessário. Suponha que você tem um programa multi-threading e você tem dois threads. Agora, você tem um trabalho na fila de trabalhos. O primeiro tópico irá verificar a fila de tarefas e, depois de encontrar a tarefa, irá começar a executá-la. O segundo tópico também irá verificar a fila de tarefas e descobrir que há uma tarefa na fila. Então, ele também vai atribuir o mesmo ponteiro de trabalho. E agora? acontece que ambas as tarefas estão a executar o mesmo trabalho. Isto vai causar uma falha de segmentação. Este é o exemplo de uma condição de raça.

A solução para este problema é a MUTEX. MUTEX é uma espécie de fechadura que tranca um fio de cada vez. Se outro tópico quiser fechá-lo, o tópico fica simplesmente bloqueado.

O tópico MUTEX neste ficheiro pdf link realmente vale a pena ler.

Os Mutexes são úteis em situações em que é necessário impor o acesso exclusivo a um recurso em vários processos, onde um bloqueio regular não ajuda, uma vez que só funciona em threads cruzados.

Existem algumas grandes respostas aqui, aqui está outra grande analogia para explicar o que mutex é:

Considerar Casa de banho única com uma chave . Quando alguém entra, pega na chave e a sanita está ocupada. Se alguém precisa de usar a casa de banho, tem de esperar numa fila de espera. Quando a pessoa no banheiro é feito , Eles passam a chave para a próxima pessoa na fila. Faz sentido, certo?

Converter a casa de banho em the story to a shared resource , and the key to a mutex . Levar a chave para a casa de banho (adquirir uma fechadura) permite-lhe usá-la. Se não houver chave (a fechadura está trancada), você tem que esperar. Quando a chave é devolvida pela Pessoa (solte a fechadura) Você está livre para adquiri-la agora.

O que é umMutex ?

O mutex (na verdade, o termo mutex é curto para a exclusão mútua) também conhecido como spinlock é a ferramenta de sincronização mais simples que é usado para proteger regiões críticas e, assim, prevenir as condições de corrida. Isso é um thread deve adquirir um lock antes de entrar em uma seção crítica (na seção crítica vários threads compartilham uma variável comum, atualizando uma tabela, escrevendo um arquivo e assim por diante), ele libera o lock quando ele deixa a seção crítica.

O que é uma condição de raça?

Uma condição de corrida ocorre quando dois ou mais threads podem acessar dados compartilhados e eles tentam alterá-lo ao mesmo tempo. Como o algoritmo de agendamento thread pode trocar entre threads a qualquer momento, você não sabe a ordem pela qual os threads tentarão acessar os dados compartilhados. Portanto, o resultado da mudança de dados é dependente do algoritmo de agendamento thread, ou seja, ambos os threads são "corrida" para acessar/alterar o dado.

Exemplo da vida Real:

Quando estou a ter uma grande discussão no trabalho, uso uma borracha. frango que guardo na minha secretária para ocasiões como esta. Pessoa segurar a galinha é a única pessoa que pode falar. Se não segure a galinha que não pode falar. Só pode indicar que queres o frango e espera até o teres antes de falares. Quando você acabou de falar, você pode entregar o frango de volta para o moderador que vai entregá-lo à próxima pessoa a falar. Isto garante que as pessoas não falam umas sobre as outras, e também têm as suas próprias espaço para conversar. Substitua galinha por Mutex e pessoa por linha e basicamente tem o conceito de mutex.

@Xetius

Utilização em C#:

Este exemplo mostra como um objecto Mutex local é usado para sincronizar o acesso a um recurso protegido. Porque cada linha de chamada é bloqueada até que adquira a propriedade de o mutex, ele deve chamar o método ReleaseMutex para liberar a propriedade do thread.

using System;
using System.Threading;

class Example
{
    // 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 newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        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.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name);
        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", 
            Thread.CurrentThread.Name);

        // Release the Mutex.
        mut.ReleaseMutex();
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name);
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread2 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread3 is requesting the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
//       Thread3 has released the mutex
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       Thread2 has released the mutex

Mutex de referência MSDN