Thread synchronization with Mutex in Ruby - Mini Project: Build & Apply

Thread synchronization with Mutex

📖 Scenario: You are creating a simple Ruby program where multiple threads try to update a shared counter. Without control, the counter can get wrong values because threads interfere with each other.To fix this, you will use a Mutex to make sure only one thread changes the counter at a time.

🎯 Goal: Build a Ruby program that uses a Mutex to safely update a shared counter from multiple threads.

📋 What You'll Learn

Create a shared counter variable

Create a Mutex object

Use multiple threads to increment the counter

Use the Mutex to synchronize access to the counter

Print the final value of the counter

💡 Why This Matters

🌍 Real World

Mutexes are used in programs where many parts run at the same time and share data. They help avoid mistakes when data is changed by more than one part at once.

💼 Career

Understanding thread synchronization and mutexes is important for software developers working on multi-threaded applications, servers, and any program that needs safe data sharing.

1

Create a shared counter variable

Create a variable called counter and set it to 0.

Ruby

# Create a variable called counter and set it to 0
# Your code here

Need a hint?

Use counter = 0 to start the count at zero.

2

Create a Mutex object

Create a variable called mutex and set it to a new Mutex object using Mutex.new.

Ruby

counter = 0
# Create a variable called mutex and set it to Mutex.new
# Your code here

Need a hint?

Use mutex = Mutex.new to create a new mutex.

3

Create threads and synchronize counter increment

Create an array called threads. Use a 5.times loop to create 5 threads. Inside each thread, use mutex.synchronize to safely increment counter by 1.

Ruby

counter = 0
mutex = Mutex.new
# Create 5 threads that increment counter safely using mutex.synchronize
# Your code here

Need a hint?

Use threads = [] to hold threads. Use 5.times do to create threads. Inside each thread, wrap counter += 1 with mutex.synchronize do ... end. Use threads.each(&:join) to wait for all threads.

4

Print the final counter value

Write a puts statement to print the value of counter.

Ruby

counter = 0
mutex = Mutex.new
threads = []
5.times do
  threads << Thread.new do
    mutex.synchronize do
      counter += 1
    end
  end
end
threads.each(&:join)
# Print the final value of counter
# Your code here

Need a hint?

Use puts counter to show the final count.