multithreading - operativos - pthread mutex lock

¿Qué es un mutex?

Question

Un mutex es un concepto de programación que se utiliza con frecuencia para resolver problemas de subprocesos múltiples. Mi pregunta a la comunidad:

¿Qué es un mutex y cómo lo usas?

Answer 1

Aquí hay algunas respuestas geniales, aquí hay otra gran analogía para explicar qué es el mutex :

Considere un solo inodoro con llave . Cuando alguien entra, toma la llave y el inodoro está ocupado . Si alguien más necesita usar el inodoro, debe esperar en una cola . Cuando la persona en el baño termina , pasan la llave a la siguiente persona en la cola. Tiene sentido, ¿verdad?

Convierta el inodoro de la historia en un recurso compartido y la clave para un mutex . Llevar la llave al baño (adquirir una cerradura) le permite usarla. Si no hay llave (la cerradura está bloqueada) tienes que esperar. Cuando la persona devuelva la llave ( libere el candado ), podrá adquirirla ahora.

Answer 2

Cuando estoy teniendo una gran discusión en el trabajo, uso un pollo de goma que tengo en mi escritorio para esas ocasiones. La persona que tiene el pollo es la única persona que puede hablar. Si no tienes el pollo no puedes hablar. Solo puedes indicar que quieres el pollo y esperar hasta que lo consigas antes de hablar. Una vez que haya terminado de hablar, puede devolverle el pollo al moderador, quien se lo entregará a la siguiente persona para que hable. Esto garantiza que las personas no se hablen entre sí y que también tengan su propio espacio para hablar.

Reemplace el pollo con Mutex y la persona con hilo y básicamente tiene el concepto de mutex.

Por supuesto, no hay tal cosa como un mutex de goma. Sólo pollo de goma. Mis gatos una vez tuvieron un ratón de goma, pero se lo comieron.

Por supuesto, antes de usar el pollo de goma, debe preguntarse si realmente necesita a 5 personas en una habitación y no sería más fácil hacerlo con una sola persona en la habitación haciendo todo el trabajo. En realidad, esto solo está extendiendo la analogía, pero entiendes la idea.

Answer 3

Cuando tiene una aplicación de múltiples subprocesos, los diferentes subprocesos a veces comparten un recurso común, como una variable o similar. Con frecuencia, no se puede acceder a esta fuente compartida al mismo tiempo, por lo que se necesita una construcción para garantizar que solo un hilo esté utilizando ese recurso a la vez.

El concepto se denomina "exclusión mutua" (Mutex corto) y es una forma de garantizar que solo se permita un hilo dentro de esa área, utilizando ese recurso, etc.

La forma de usarlos es específica del idioma, pero a menudo (si no siempre) se basa en un sistema operativo de exclusión mutua.

Algunos lenguajes no necesitan esta construcción, debido al paradigma, por ejemplo, la programación funcional (Haskell, ML son buenos ejemplos).

¡Ahora, pregúntale a google cómo usarlos! :)

Answer 4

En C #, el mutex común utilizado es el Monitor . El tipo es '' System.Threading.Monitor ''. También se puede usar implícitamente a través de la declaración '' lock(Object) ''. Un ejemplo de su uso es cuando se construye una clase 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;
    }
}

La instrucción de bloqueo que utiliza el objeto de bloqueo privado crea una sección crítica. Exigir a cada hilo que espere hasta que el anterior termine. El primer hilo entrará en la sección e inicializará la instancia. El segundo hilo esperará, accederá a la sección y obtendrá la instancia inicializada.

Cualquier tipo de sincronización de un miembro estático puede usar la declaración de bloqueo de manera similar.

Answer 5

Exclusión mutua. Aquí está la entrada de Wikipedia en él:

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

El punto de un mutex es sincronizar dos hilos. Cuando tiene dos subprocesos que intentan acceder a un solo recurso, el patrón general es tener el primer bloque de código que intenta acceder para establecer el mutex antes de ingresar el código. Cuando el segundo bloque de código intenta acceder, ve que el mutex está configurado y espera hasta que se complete el primer bloque de código (y anula la configuración del mutex), luego continúa.

Los detalles específicos de cómo se logra esto obviamente varían enormemente según el lenguaje de programación.

Answer 6

Las exclusiones mutuas son útiles en situaciones en las que necesita forzar el acceso exclusivo a un recurso a través de múltiples procesos, donde un bloqueo regular no ayuda ya que solo funciona a través de subprocesos.

Answer 7

Para comprender MUTEX al principio, debe saber qué es la "condición de raza" y solo entonces comprenderá por qué se necesita MUTEX. Supongamos que tiene un programa de subprocesos múltiples y tiene dos subprocesos. Ahora, tienes un trabajo en la cola de trabajos. El primer hilo comprobará la cola de trabajos y, después de encontrar el trabajo, comenzará a ejecutarlo. El segundo hilo también verificará la cola de trabajos y encontrará que hay un trabajo en la cola. Por lo tanto, también asignará el mismo puntero de trabajo. Entonces, ahora que sucede, ambos hilos están ejecutando el mismo trabajo. Esto causará una falla de segmentación. Este es el ejemplo de una condición de carrera.

La solución a este problema es MUTEX. MUTEX es un tipo de bloqueo que bloquea un hilo a la vez. Si otro hilo quiere bloquearlo, el hilo simplemente se bloquea.

El tema MUTEX en este enlace de archivo pdf realmente vale la pena leerlo.

Answer 8

Un Mutex es una bandera mutuamente exclusiva. Actúa como un guardián de puerta para una sección de código que permite un hilo y bloquea el acceso a todos los demás. Esto asegura que el código que se está controlando solo será golpeado por un solo hilo a la vez. Solo asegúrate de liberar el mutex cuando hayas terminado. :)

Answer 9

¿Qué es un Mutex ?

El mutex (De hecho, el término mutex es corto para la exclusión mutua), también conocido como spinlock, es la herramienta de sincronización más simple que se utiliza para proteger regiones críticas y, por lo tanto, prevenir las condiciones de carrera. Es decir, un subproceso debe adquirir un bloqueo antes de ingresar a una sección crítica (en la sección crítica, varios subprocesos comparten una variable común, actualizan una tabla, escriben un archivo, etc.), liberan el bloqueo cuando abandona la sección crítica.

¿Qué es una condición de raza ?

Se produce una condición de carrera cuando dos o más subprocesos pueden acceder a datos compartidos e intentan cambiarlos al mismo tiempo. Debido a que el algoritmo de programación de subprocesos puede intercambiar entre subprocesos en cualquier momento, no sabe el orden en el que los subprocesos intentarán acceder a los datos compartidos. Por lo tanto, el resultado del cambio en los datos depende del algoritmo de programación de subprocesos, es decir, ambos subprocesos están "compitiendo" para acceder / cambiar los datos.

Ejemplo de la vida real:

Cuando estoy teniendo una gran discusión en el trabajo, uso un pollo de goma que tengo en mi escritorio para esas ocasiones. La persona que tiene el pollo es la única persona que puede hablar. Si no tienes el pollo no puedes hablar. Solo puedes indicar que quieres el pollo y esperar hasta que lo consigas antes de hablar. Una vez que haya terminado de hablar, puede devolverle el pollo al moderador, quien se lo entregará a la siguiente persona para que hable. Esto garantiza que las personas no se hablen entre sí y que también tengan su propio espacio para hablar.

Reemplace el pollo con Mutex y la persona con hilo y básicamente tiene el concepto de mutex.

@Xetius

Uso en C #:

Este ejemplo muestra cómo se utiliza un objeto Mutex local para sincronizar el acceso a un recurso protegido. Debido a que cada subproceso que realiza la llamada se bloquea hasta que adquiera la propiedad del mutex, debe llamar al método ReleaseMutex para liberar la propiedad del subproceso.

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

MSDN Reference Mutex