Introdução

A simultaneidade é uma ferramenta poderosa em programação, permitindo que vários threads executem código simultaneamente. No entanto, com este poder vem a responsabilidade de gerir os recursos partilhados de forma segura. Em Ruby, Mutex (abreviação de exclusão mútua) é um componente chave para garantir que apenas um thread possa acessar um recurso por vez, evitando possível corrupção de dados ou comportamento imprevisível.
Neste blog, exploraremos como usar Mutex em Ruby, apoiado por código de exemplo e um cenário da vida real para ilustrar sua aplicação prática.

O que é um Mutex?

Um Mutex é um objeto usado para gerenciar a sincronização de threads. Quando um thread bloqueia um Mutex, qualquer outro thread que tente bloquear o mesmo Mutex será colocado em espera até que o primeiro thread o libere. Este mecanismo garante que seções críticas do código, onde os recursos compartilhados são acessados, sejam executadas por apenas um thread por vez.

Por que usar um Mutex?

Imagine um cenário onde vários threads estão modificando a mesma variável ou gravando no mesmo arquivo. Sem a sincronização adequada, o resultado pode ser imprevisível ou incorreto. Um Mutex ajuda a evitar tais problemas, garantindo que apenas um thread possa acessar o recurso compartilhado a qualquer momento.

Como usar o mutex em 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}"

Neste exemplo:

• Inicializamos um objeto Mutex.
• Criamos um recurso compartilhado (contador) que será acessado por vários threads.
• Criamos 10 threads, cada uma incrementando o contador 1000 vezes.
• Dentro do bloco mutex.synchronize, garantimos que apenas um thread pode modificar o contador por vez.
• Finalmente, imprimimos o valor final do contador, que deve ser 10000 se o Mutex tiver sincronizado corretamente o acesso.

Cenário da vida real: gerenciamento de transações de contas bancárias

Para entender a aplicação do Mutex na vida real, vamos considerar um cenário em que vários threads representam transações em uma conta bancária. Cada transação pode envolver depósito ou retirada de dinheiro, e devemos garantir que o saldo da conta permaneça correto.

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 




  
  
  Neste cenário:

• Definimos uma classe BankAccount com métodos de depósito e retirada.
• Criamos uma instância BankAccount compartilhada com um saldo inicial de 1.000.
• Criamos dois tópicos: um para depositar dinheiro e outro para sacar dinheiro.
• Usamos um Mutex para sincronizar o acesso aos métodos de depósito e saque, garantindo que apenas uma transação possa modificar o saldo da conta por vez.
• Finalmente, imprimimos o saldo final da conta, que deve refletir com precisão todas as transações.

Conclusão

Usar Mutex em Ruby é essencial ao lidar com simultaneidade e recursos compartilhados. Ele fornece uma maneira simples, mas eficaz, de garantir que apenas um thread possa acessar uma seção crítica do código por vez, evitando possíveis problemas como corrupção de dados ou condições de corrida.