Thread synchronization with Mutex in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby code using Mutex?

Consider the following Ruby code that uses a Mutex to synchronize threads incrementing a shared counter.

require 'thread'
counter = 0
mutex = Mutex.new
threads = []

10.times do
  threads << Thread.new do
    100.times do
      mutex.synchronize do
        counter += 1
      end
    end
  end
end

threads.each(&:join)
puts counter

What will be printed?

Ruby

require 'thread'
counter = 0
mutex = Mutex.new
threads = []

10.times do
  threads << Thread.new do
    100.times do
      mutex.synchronize do
        counter += 1
      end
    end
  end
end

threads.each(&:join)
puts counter

A 0

B A number less than 1000 due to race conditions

C An error because counter is not thread-safe

D 1000

💡 Hint

Think about what the Mutex does to the shared variable.

The Mutex ensures only one thread at a time can increment the counter. Since 10 threads each increment 100 times, the final count is 1000.

❓ Predict Output

intermediate

What happens if Mutex is removed from this Ruby code?

Look at this Ruby code where multiple threads increment a shared variable without a Mutex:

counter = 0
threads = []

10.times do
  threads << Thread.new do
    100.times do
      counter += 1
    end
  end
end

threads.each(&:join)
puts counter

What is the most likely output?

Ruby

counter = 0
threads = []

10.times do
  threads << Thread.new do
    100.times do
      counter += 1
    end
  end
end

threads.each(&:join)
puts counter

A A number less than 1000 due to race conditions

B 1000

C An error because counter is not thread-safe

D 0

💡 Hint

Think about what happens when multiple threads change the same variable without protection.

Without a Mutex, threads can interfere with each other causing some increments to be lost. So the final count is usually less than 1000.

🔧 Debug

advanced

Identify the error in this Ruby Mutex usage

Find the error in this Ruby code snippet that tries to use a Mutex to protect a shared resource:

mutex = Mutex.new
counter = 0

Thread.new do
  mutex.lock
  counter += 1
end

mutex.unlock
puts counter

Ruby

mutex = Mutex.new
counter = 0

Thread.new do
  mutex.lock
  counter += 1
end

mutex.unlock
puts counter

A counter is not initialized before use

B Missing mutex.synchronize block causes race condition

C Calling mutex.unlock outside the thread causes a ThreadError

D Thread never starts because of missing join

💡 Hint

Think about which thread owns the lock when unlocking.

Only the thread that locked the mutex can unlock it. Unlocking from the main thread causes a ThreadError.

📝 Syntax

advanced

Which Ruby code correctly uses Mutex to protect a shared array?

Choose the Ruby code snippet that correctly uses a Mutex to safely append to a shared array from multiple threads.

A

mutex = Mutex.new
arr = []
threads = []
10.times do
  threads << Thread.new do
    mutex.synchronize { arr << 1 }
  end
end
threads.each(&:join)
puts arr.size

B

mutex = Mutex.new
arr = []
threads = []
10.times do
  threads << Thread.new do
    mutex.synchronize do
      arr.push(1)
    end
  end
end
threads.each(&:join)
puts arr.size

C

mutex = Mutex.new
arr = []
threads = []
10.times do
  threads << Thread.new do
    mutex.lock
    arr << 1
  end
  mutex.unlock
end
threads.each(&:join)
puts arr.size

D

mutex = Mutex.new
arr = []
threads = []
10.times do
  threads << Thread.new do
    arr << 1
  end
end
threads.each(&:join)
puts arr.size

💡 Hint

Look for proper use of synchronize and thread joining.

Option A correctly uses mutex.synchronize inside each thread and waits for all threads to finish before printing the array size.

🚀 Application

expert

How many items will the shared hash contain after this Ruby threaded code?

Consider this Ruby code that uses a Mutex to safely add keys to a shared hash from multiple threads:

require 'thread'
shared_hash = {}
mutex = Mutex.new
threads = []

5.times do |i|
  threads << Thread.new do
    10.times do |j|
      mutex.synchronize do
        shared_hash["key_#{i}_#{j}"] = i * j
      end
    end
  end
end

threads.each(&:join)
puts shared_hash.size

What will be printed?

Ruby

require 'thread'
shared_hash = {}
mutex = Mutex.new
threads = []

5.times do |i|
  threads << Thread.new do
    10.times do |j|
      mutex.synchronize do
        shared_hash["key_#{i}_#{j}"] = i * j
      end
    end
  end
end

threads.each(&:join)
puts shared_hash.size

A 5

B 50

C 10

D 0

💡 Hint

Count how many unique keys are added by all threads combined.

There are 5 threads, each adding 10 unique keys. So total keys = 5 * 10 = 50.