Thread safety concepts in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of thread increment without synchronization

What is the output of this Ruby code that increments a shared counter from multiple threads without any synchronization?

Ruby

counter = 0
threads = []
10.times do
  threads << Thread.new do
    1000.times { counter += 1 }
  end
end
threads.each(&:join)
puts counter

A A number greater than 10000

B 10000

C Raises a runtime error

D A number less than 10000

💡 Hint

Think about what happens when multiple threads update the same variable without locks.

Because the increment operation is not atomic, some increments can be lost due to race conditions, so the final counter is usually less than 10000.

🧠 Conceptual

intermediate

Understanding Mutex usage in Ruby

Why do we use a Mutex in Ruby when working with threads?

A To allow multiple threads to access a resource simultaneously

B To speed up thread execution by skipping locks

C To prevent multiple threads from accessing a shared resource at the same time

D To automatically create new threads

💡 Hint

Think about what happens if two threads try to change the same data at once.

A Mutex ensures that only one thread can access a shared resource at a time, preventing race conditions.

🔧 Debug

advanced

Identify the cause of inconsistent output in threaded code

This Ruby code uses threads to append to an array. Why might the final array length be less than expected?

Ruby

arr = []
threads = []
5.times do
  threads << Thread.new do
    100.times { arr << 1 }
  end
end
threads.each(&:join)
puts arr.length

A Because Array#<< is not thread-safe and can cause lost updates

B Because threads are not started properly

C Because the array is frozen and cannot be modified

D Because the join method is not waiting for threads

💡 Hint

Consider if appending to an array is safe when multiple threads do it at once.

Appending to an array is not thread-safe in Ruby, so concurrent appends can overwrite or lose data, causing fewer elements than expected.

📝 Syntax

advanced

Identify the syntax error in thread synchronization code

Which option contains a syntax error in Ruby code that uses a Mutex to synchronize threads?

Ruby

mutex = Mutex.new
counter = 0
threads = []
10.times do
  threads << Thread.new do
    mutex.synchronize do
      counter += 1
    end
  end
end
threads.each(&:join)
puts counter

A mutex.synchronize counter += 1 end

B mutex.synchronize do counter += 1 end

C mutex.synchronize { counter += 1 }

D

mutex.synchronize do
  counter += 1
end

💡 Hint

Check the syntax of the block passed to synchronize.

Option A is missing the 'do' keyword before the block and has an extra 'end', causing a syntax error.

🚀 Application

expert

Determine the final value of a shared variable with thread-safe increments

Given this Ruby code using a Mutex to safely increment a shared counter from multiple threads, what is the final value of counter?

Ruby

counter = 0
mutex = Mutex.new
threads = []
20.times do
  threads << Thread.new do
    500.times do
      mutex.synchronize { counter += 1 }
    end
  end
end
threads.each(&:join)
puts counter

A Raises a deadlock error

B 10000

C Greater than 10000 due to double increments

D Less than 10000 due to race conditions

💡 Hint

Mutex ensures increments happen one at a time without loss.

Mutex synchronization prevents race conditions, so all increments are counted, resulting in 20 * 500 = 10000.