Introducción

La concurrencia es una herramienta poderosa en programación que permite que múltiples subprocesos ejecuten código simultáneamente. Sin embargo, este poder conlleva la responsabilidad de gestionar los recursos compartidos de forma segura. En Ruby, Mutex (abreviatura de exclusión mutua) es un componente clave para garantizar que solo un hilo pueda acceder a un recurso a la vez, evitando posibles daños en los datos o comportamientos impredecibles.
En este blog, exploraremos cómo usar Mutex en Ruby, respaldado por código de muestra y un escenario de la vida real para ilustrar su aplicación práctica.

¿Qué es un Mutex?

Un Mutex es un objeto utilizado para gestionar la sincronización de subprocesos. Cuando un subproceso bloquea un Mutex, cualquier otro subproceso que intente bloquear el mismo Mutex quedará en espera hasta que el primer subproceso lo libere. Este mecanismo garantiza que las secciones críticas del código, donde se accede a los recursos compartidos, sean ejecutadas por un solo subproceso a la vez.

¿Por qué utilizar un Mutex?

Imagínese un escenario en el que varios subprocesos modifican la misma variable o escriben en el mismo archivo. Sin una sincronización adecuada, el resultado podría ser impredecible o incorrecto. Un Mutex ayuda a evitar estos problemas al garantizar que solo un hilo pueda acceder al recurso compartido en un momento dado.

Cómo utilizar Mutex en Ruby

require 'thread'

# Initialize a Mutex
mutex = Mutex.new

# Shared resource
counter = 0

# Create threads
threads = 10.times.map do
  Thread.new do
    1000.times do
      # Lock the mutex before modifying the shared resource
      mutex.synchronize do
        counter  = 1
      end
    end
  end
end

# Wait for all threads to finish
threads.each(&:join)

puts "Final counter value: #{counter}"

En este ejemplo:

• Inicializamos un objeto Mutex.
• Creamos un recurso compartido (contador) al que accederán varios hilos.
• Creamos 10 hilos, cada uno incrementando el contador 1000 veces.
• Dentro del bloque mutex.synchronize, nos aseguramos de que solo un hilo pueda modificar el contador a la vez.
• Finalmente, imprimimos el valor final del contador, que debería ser 10000 si el Mutex ha sincronizado correctamente el acceso.

Escenario de la vida real: gestión de transacciones de cuentas bancarias

Para comprender la aplicación de Mutex en la vida real, consideremos un escenario en el que varios subprocesos representan transacciones en una cuenta bancaria. Cada transacción puede implicar depositar o retirar dinero, y debemos asegurarnos de que el saldo de la cuenta siga siendo exacto.

require 'thread'

# Initialize a Mutex
account_mutex = Mutex.new

# Bank account class
class BankAccount
  attr_reader :balance

  def initialize(balance = 0)
    @balance = balance
  end

  def deposit(amount)
    @balance  = amount
  end

  def withdraw(amount)
    @balance -= amount
  end
end

# Shared bank account
account = BankAccount.new(1000)

# Transactions
threads = []

# Deposit thread
threads 




  
  
  En este escenario:

• Definimos una clase BankAccount con métodos de depósito y retiro.
• Creamos una instancia compartida de BankAccount con un saldo inicial de 1000.
• Creamos dos hilos: uno para depositar dinero y otro para retirar dinero.
• Utilizamos un Mutex para sincronizar el acceso a los métodos de depósito y retiro, asegurando que solo una transacción pueda modificar el saldo de la cuenta a la vez.
• Finalmente, imprimimos el saldo final de la cuenta, que debe reflejar con precisión todas las transacciones.

Conclusión

El uso de Mutex en Ruby es esencial cuando se trata de simultaneidad y recursos compartidos. Proporciona una manera simple pero efectiva de garantizar que solo un subproceso pueda acceder a una sección crítica de código a la vez, evitando posibles problemas como corrupción de datos o condiciones de carrera.