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.

Practice

1. What does Thread.new do in Ruby?

easy

A. It creates a new thread to run code concurrently.

B. It pauses the current thread until another finishes.

C. It terminates all running threads immediately.

D. It converts a method into a thread-safe version.

Solution

1. Step 1: Understand the purpose of Thread.new

   Thread.new starts a new thread that runs the code inside its block concurrently with the main program.

2. Step 2: Compare options with the behavior

   Only It creates a new thread to run code concurrently. correctly describes creating a new thread to run code at the same time as other threads.

3. Final Answer:

   It creates a new thread to run code concurrently. -> Option A

4. Quick Check:

   Thread.new = create thread [OK]

Hint: Remember: Thread.new starts a new thread block [OK]

Common Mistakes:

• Confusing thread creation with thread termination
• Thinking Thread.new pauses threads
• Assuming Thread.new modifies methods

2. Which of the following is the correct syntax to create and start a thread in Ruby?

easy

A. Thread.start puts 'Hello from thread'

B. Thread.run { puts 'Hello from thread' }

C. Thread.create do puts 'Hello from thread' end

D. Thread.new { puts 'Hello from thread' }

Solution

1. Step 1: Recall correct thread creation syntax

   The correct way is Thread.new { ... } where the block contains the code to run.

2. Step 2: Check each option

   Thread.new { puts 'Hello from thread' } uses Thread.new with a block correctly. Options A, C, and D use invalid or non-existent methods or syntax.

3. Final Answer:

   Thread.new { puts 'Hello from thread' } -> Option D

4. Quick Check:

   Use Thread.new { } for threads [OK]

Hint: Use Thread.new with a block to start threads [OK]

Common Mistakes:

• Using Thread.start without a block
• Mistyping method names like Thread.create
• Using Thread.run which does not exist

3. What will be the output of this Ruby code?

thread = Thread.new { 5.times { |i| puts i; sleep 0.1 } }
thread.join
puts 'Done'

medium

A. 0 1 2 3 4 Done (each number on its own line)

B. Done 0 1 2 3 4 (each number on its own line)

C. Only 'Done' is printed

D. No output because thread.join blocks forever

Solution

1. Step 1: Understand thread execution and join

   The thread prints numbers 0 to 4 with a short pause. The main thread waits for it to finish because of thread.join.

2. Step 2: Determine output order

   The numbers 0 to 4 print first, each on its own line, then after the thread finishes, 'Done' prints.

3. Final Answer:

   0 1 2 3 4 Done (each number on its own line) -> Option A

4. Quick Check:

   Thread prints numbers before main prints 'Done' [OK]

Hint: join waits for thread to finish before continuing [OK]

Common Mistakes:

• Assuming 'Done' prints before numbers
• Thinking join blocks forever
• Ignoring sleep delays in thread

4. Identify the error in this Ruby code snippet:

thread = Thread.new do
  puts 'Start'
  sleep 1
  puts 'End'
end
puts 'Waiting'
thread.join

medium

A. The thread block is missing a closing end.

B. The main thread does not wait for the new thread to finish.

C. There is no error; the code runs correctly.

D. The sleep method cannot be used inside a thread.

Solution

1. Step 1: Check thread block syntax

   The thread block is properly closed with end. Syntax is correct.

2. Step 2: Verify thread execution and join

   The main thread prints 'Waiting' then calls thread.join to wait for the thread to finish. This is correct usage.

3. Final Answer:

   There is no error; the code runs correctly. -> Option C

4. Quick Check:

   Thread syntax and join usage are correct [OK]

Hint: Check block ends and join usage carefully [OK]

Common Mistakes:

• Thinking sleep is invalid in threads
• Assuming join is missing
• Miscounting block ends

5. You want to create 3 threads that each print their thread number (1, 2, 3) and then print 'Finished' after all threads complete. Which code correctly achieves this?

hard

A. 3.times do |i|
Thread.new { puts i + 1 }
end
puts 'Finished'

B. threads = []
3.times do |i|
threads << Thread.new { puts i + 1 }
end
threads.each(&:join)
puts 'Finished'

C. threads = []
3.times do |i|
threads << Thread.new { puts i }
end
puts 'Finished'
threads.each(&:join)

D. threads = []
3.times do |i|
threads << Thread.new { puts i + 1 }
end
puts 'Finished'
threads.each(&:join)

Solution

1. Step 1: Create threads storing them in an array

   threads = [] 3.times do |i| threads << Thread.new { puts i + 1 } end threads.each(&:join) puts 'Finished' correctly creates 3 threads, each printing i + 1 (1, 2, 3), and stores them in threads.

2. Step 2: Wait for all threads to finish before printing 'Finished'

   threads = [] 3.times do |i| threads << Thread.new { puts i + 1 } end threads.each(&:join) puts 'Finished' calls threads.each(&:join) to wait for all threads, then prints 'Finished'. This ensures 'Finished' prints last.

3. Final Answer:

   threads = [] 3.times do |i| threads << Thread.new { puts i + 1 } end threads.each(&:join) puts 'Finished' -> Option B

4. Quick Check:

   Store threads, join all, then print [OK]

Hint: Join all threads before printing final message [OK]

Common Mistakes:

• Not storing threads to join later
• Printing 'Finished' before threads complete
• Using wrong thread index values