Thread creation and execution in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of simple thread execution

What is the output of this Ruby code that creates and runs a thread?

Ruby

thread = Thread.new { puts "Hello from thread" }
thread.join
puts "Main thread finished"

A

Hello from thread
Main thread finished

B

Main thread finished
Hello from thread

C Hello from thread

D Main thread finished

💡 Hint

The main thread waits for the new thread to finish before printing the last line.

The thread prints its message first. The main thread waits for it to finish because of join, then prints its message.

❓ Predict Output

intermediate

Thread variable scope

What will be the output of this Ruby code involving threads and variables?

Ruby

message = "Hello"
thread = Thread.new { message = "Hi from thread" }
thread.join
puts message

A Hello

B Hi from thread

C nil

D ThreadError

💡 Hint

Threads share variables unless they are local to the thread block.

The thread changes the shared variable message. After join, the main thread prints the updated value.

❓ Predict Output

advanced

Race condition demonstration

What is the output of this Ruby code with two threads incrementing a shared counter?

Ruby

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

A ThreadError

B 1000

C 2000

D A number less than 2000

💡 Hint

Incrementing a shared variable without synchronization can cause lost updates.

Because counter += 1 is not atomic, some increments can be lost due to race conditions, so the final value is less than 2000.

❓ Predict Output

advanced

Thread exception handling

What happens when a thread raises an exception that is not rescued inside it?

Ruby

thread = Thread.new do
  raise "Oops"
end
thread.join
puts "Main thread continues"

A Uncaught exception terminates the program

B Main thread continues

C Thread silently dies, main thread continues

D Deadlock occurs

💡 Hint

By default, unhandled exceptions in threads cause the whole program to terminate.

Ruby raises the exception in the thread, which is not rescued, causing the thread to die silently while the main thread continues.

🧠 Conceptual

expert

Thread synchronization with Mutex

Why is using a Mutex important when multiple threads modify a shared variable?

A It prevents race conditions by allowing only one thread to access the variable at a time

B It allows threads to share local variables safely

C It automatically fixes syntax errors in thread code

D It speeds up the program by running threads in parallel without waiting

💡 Hint

Think about how to avoid two threads changing the same data at the same time.

Mutex locks ensure only one thread can access the shared variable at once, preventing data corruption from race conditions.