Введение

Параллелизм — это мощный инструмент программирования, позволяющий нескольким потокам одновременно выполнять код. Однако вместе с этими полномочиями приходит и ответственность за безопасное управление общими ресурсами. В Ruby Mutex (сокращение от взаимного исключения) является ключевым компонентом, гарантирующим, что только один поток может получить доступ к ресурсу одновременно, предотвращая потенциальное повреждение данных или непредсказуемое поведение.
В этом блоге мы рассмотрим, как использовать Mutex в Ruby, при поддержке примера кода и реального сценария, иллюстрирующего его практическое применение.

Что такое мьютекс?

Мьютекс — это объект, используемый для управления синхронизацией потоков. Когда один поток блокирует мьютекс, любой другой поток, пытающийся заблокировать тот же мьютекс, будет приостановлен до тех пор, пока первый поток его не освободит. Этот механизм гарантирует, что критические разделы кода, к которым осуществляется доступ к общим ресурсам, выполняются только одним потоком за раз.

Зачем использовать мьютекс?

Представьте себе сценарий, в котором несколько потоков изменяют одну и ту же переменную или записывают данные в один и тот же файл. Без надлежащей синхронизации результат может быть непредсказуемым или неверным. Мьютекс помогает избежать таких проблем, гарантируя, что только один поток может получить доступ к общему ресурсу в любой момент времени.

Как использовать мьютекс в 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}"

В этом примере:

• Мы инициализируем объект Mutex.
• Мы создаем общий ресурс (счетчик), к которому будут обращаться несколько потоков.
• Мы создаем 10 потоков, каждый из которых увеличивает счетчик 1000 раз.
• Внутри блока mutex.synchronize мы гарантируем, что только один поток может одновременно изменять счетчик.
• Наконец, мы печатаем окончательное значение счетчика, которое должно быть 10000, если мьютекс правильно синхронизировал доступ.

Реальный сценарий: управление транзакциями по банковским счетам

Чтобы понять реальное применение Mutex, давайте рассмотрим сценарий, в котором несколько потоков представляют транзакции на банковском счете. Каждая транзакция может включать внесение или снятие денег, и мы должны гарантировать, что баланс счета остается точным.

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 




  
  
  В этом сценарии:

• Мы определяем класс BankAccount с методами пополнения и вывода средств.
• Мы создаем общий экземпляр BankAccount с начальным балансом 1000.
• Мы создаем две темы: одну для внесения денег и одну для вывода денег.
• Мы используем мьютекс для синхронизации доступа к методам пополнения и вывода средств, гарантируя, что только одна транзакция может изменить баланс счета одновременно.
• Наконец, мы печатаем окончательный баланс счета, который должен точно отражать все транзакции.

Заключение

Использование Mutex в Ruby важно при работе с параллелизмом и общими ресурсами. Он обеспечивает простой, но эффективный способ гарантировать, что только один поток может одновременно получить доступ к критическому разделу кода, предотвращая потенциальные проблемы, такие как повреждение данных или состояния гонки.