Thread creation and execution in Ruby - Mini Project: Build & Apply

Thread creation and execution

📖 Scenario: You are building a simple Ruby program that uses threads to run tasks at the same time. This helps your program do multiple things without waiting for one to finish before starting another.

🎯 Goal: Create and run threads in Ruby to print messages concurrently.

📋 What You'll Learn

Create a thread with a block of code

Start the thread

Use Thread.new to create threads

Use join to wait for threads to finish

Print messages from threads

💡 Why This Matters

🌍 Real World

Threads let programs do many things at once, like downloading files while showing progress or handling multiple users in a chat app.

💼 Career

Understanding threads is important for jobs involving concurrent programming, improving app performance, and working with real-time systems.

1

Create a thread that prints a message

Create a thread called thread1 using Thread.new that prints the message "Hello from thread 1" inside the thread block.

Ruby

# Create a thread called thread1 that prints "Hello from thread 1"
# Your code here

Hint

Use Thread.new do ... end to create a thread and put puts inside the block.

2

Create a second thread with a different message

Create a second thread called thread2 using Thread.new that prints the message "Hello from thread 2" inside the thread block.

Ruby

thread1 = Thread.new do
  puts "Hello from thread 1"
end
# Create a thread called thread2 that prints "Hello from thread 2"
# Your code here

Hint

Use the same pattern as thread1 but change the variable name and message.

3

Wait for both threads to finish

Use the join method on both thread1 and thread2 to make sure the main program waits for both threads to complete.

Ruby

thread1 = Thread.new do
  puts "Hello from thread 1"
end

thread2 = Thread.new do
  puts "Hello from thread 2"
end

# Wait for thread1 and thread2 to finish
# Your code here

Hint

Call join on each thread variable to wait for them.

4

Print a final message after threads complete

Add a puts statement after joining the threads to print "Both threads have finished".

Ruby

thread1 = Thread.new do
  puts "Hello from thread 1"
end

thread2 = Thread.new do
  puts "Hello from thread 2"
end

thread1.join
thread2.join

# Print "Both threads have finished" here
# Your code here

Hint

Use puts "Both threads have finished" after the join calls.

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