How to Use Mutex in Ruby: A Comprehensive Guide

Introduction

Concurrency is a powerful tool in programming, enabling multiple threads to execute code simultaneously. However, with this power comes the responsibility to manage shared resources safely. In Ruby, Mutex (short for mutual exclusion) is a key component in ensuring that only one thread can access a resource at a time, preventing potential data corruption or unpredictable behaviour.
In this blog, we'll explore how to use Mutex in Ruby, supported by sample code and a real-life scenario to illustrate its practical application.

What is a Mutex?

A Mutex is an object used to manage the synchronization of threads. When one thread locks a Mutex, any other thread that attempts to lock the same Mutex will be put on hold until the first thread releases it. This mechanism ensures that critical sections of code, where shared resources are accessed, are executed by only one thread at a time.

Why Use a Mutex?

Imagine a scenario where multiple threads are modifying the same variable or writing to the same file. Without proper synchronization, the result could be unpredictable or incorrect. A Mutex helps to avoid such issues by ensuring that only one thread can access the shared resource at any given time.

How to Use Mutex in 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}"

In this example:

• We initialize a Mutex object.
• We create a shared resource (counter) that will be accessed by multiple threads.
• We create 10 threads, each incrementing the counter 1000 times.
• Inside the mutex.synchronize block, we ensure that only one thread can modify the counter at a time.
• Finally, we print the final value of counter, which should be 10000 if the Mutex has properly synchronized the access.

Real-Life Scenario: Managing Bank Account Transactions

To understand the real-life application of Mutex, let's consider a scenario where multiple threads represent transactions on a bank account. Each transaction may involve depositing or withdrawing money, and we must ensure that the account balance remains accurate.

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 << Thread.new do 100.times do account_mutex.synchronize do account.deposit(50) end end end # Withdraw thread threads << Thread.new do 100.times do account_mutex.synchronize do account.withdraw(30) end end end # Wait for all threads to finish threads.each(&:join) puts "Final account balance: #{account.balance}"

In this scenario:

• We define a BankAccount class with deposit and withdraw methods.
• We create a shared BankAccount instance with an initial balance of 1000.
• We create two threads: one for depositing money and one for withdrawing money.
• We use a Mutex to synchronize access to the deposit and withdraw methods, ensuring that only one transaction can modify the account balance at a time.
• Finally, we print the final account balance, which should accurately reflect all transactions.

Conclusion

Using Mutex in Ruby is essential when dealing with concurrency and shared resources. It provides a simple yet effective way to ensure that only one thread can access a critical section of code at a time, preventing potential issues like data corruption or race conditions.

The above is the detailed content of How to Use Mutex in Ruby: A Comprehensive Guide. For more information, please follow other related articles on the PHP Chinese website!