Why concurrency matters in Ruby - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new thread that prints 'Hello from thread!'.

Ruby

thread = Thread.new { puts [1] }
thread.join

Drag options to blanks, or click blank then click option'

A"Hello from thread!"

BHello from thread!

Cprint 'Hello from thread!'

Dputs Hello from thread!

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to put quotes around the string.

Using print instead of puts inside the thread block.

In Ruby, strings must be quoted. To print the message, we use puts with a quoted string.

2fill in blank

medium

Complete the code to start two threads that each print a different message.

Ruby

t1 = Thread.new { puts [1] }
t2 = Thread.new { puts [2] }
t1.join
t2.join

Drag options to blanks, or click blank then click option'

A"Thread 1 running"

B"Thread 2 running"

C"Running thread"

D"Thread running"

Attempts:

3 left

💡 Hint

Common Mistakes

Not quoting the string.

Using the same message for both threads.

The first thread prints "Thread 1 running" and the second prints "Thread 2 running".

3fill in blank

hard

Fix the error in the code to safely increment a shared counter using a Mutex.

Ruby

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

Drag options to blanks, or click blank then click option'

Asynchronize

Bunlock

Cwait

Dlock

Attempts:

3 left

💡 Hint

Common Mistakes

Using lock without unlocking.

Using unlock directly.

Using wait which is not a Mutex method.

To safely access shared data in Ruby threads, use Mutex#synchronize which locks and unlocks automatically.

4fill in blank

hard

Fill both blanks to create a thread that sleeps for 2 seconds and then prints a message.

Ruby

thread = Thread.new do
  sleep [1]
  puts [2]
end
thread.join

Drag options to blanks, or click blank then click option'

A2

B"Done sleeping"

C"Sleeping done"

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Putting quotes around the number 2.

Not quoting the message string.

The thread sleeps for 2 seconds, then prints the message 'Done sleeping'.

5fill in blank

hard

Fill all three blanks to create a thread-safe counter increment using Mutex and threads.

Ruby

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

Drag options to blanks, or click blank then click option'

Asynchronize

B+=

C==

Dlock

Attempts:

3 left

💡 Hint

Common Mistakes

Using lock without unlocking.

Using = instead of +=.

Using = instead of == for comparison.

Use synchronize to lock the counter increment safely, += to add 1, and == to check the final value.

Practice

1. Why is concurrency important in Ruby programs?

easy

A. It allows the program to do multiple tasks at the same time, improving speed.

B. It makes the program use less memory.

C. It automatically fixes bugs in the code.

D. It changes the program's output format.

Solution

1. Step 1: Understand concurrency's purpose

   Concurrency lets a program handle multiple tasks simultaneously instead of one after another.

2. Step 2: Identify the benefit in Ruby

   This improves speed and responsiveness, especially when waiting for slow tasks or handling many users.

3. Final Answer:

   It allows the program to do multiple tasks at the same time, improving speed. -> Option A

4. Quick Check:

   Concurrency = multitasking speedup [OK]

Hint: Concurrency means doing many things at once [OK]

Common Mistakes:

• Thinking concurrency reduces memory usage
• Believing concurrency fixes bugs automatically
• Confusing concurrency with output formatting

2. Which of the following is the correct way to start a new thread in Ruby?

easy

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

B. thread.start { puts 'Hello from thread' }

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

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

Solution

1. Step 1: Recall Ruby thread syntax

   In Ruby, threads are created using Thread.new with a block of code.

2. Step 2: Check each option

   Only Thread.new { ... } is valid Ruby syntax to start a thread.

3. Final Answer:

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

4. Quick Check:

   Thread.new starts threads [OK]

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

Common Mistakes:

• Using incorrect method names like thread.start
• Trying Java-style thread creation syntax
• Confusing Thread.run with Thread.new

3. What will this Ruby code output?

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

medium

A. Only 'Done' is printed

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

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

D. No output because of an error

Solution

1. Step 1: Understand thread execution

   The thread prints numbers 0 to 4 with a short pause between each.

2. Step 2: Effect of thread.join

   thread.join waits for the thread to finish before continuing to print 'Done'.

3. Final Answer:

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

4. Quick Check:

   Thread prints numbers then main prints Done [OK]

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

Common Mistakes:

• Thinking 'Done' prints before numbers
• Assuming no output due to thread
• Ignoring thread.join effect

4. What is wrong with this Ruby code that tries to use concurrency?

threads = []
i = 0
5.times do
  threads << Thread.new do
    puts i
  end
  i += 1
end
threads.each(&:join)

medium

A. The code will cause a syntax error.

B. The variable i is shared and may cause unexpected output.

C. threads.each(&:join) should be threads.join.

D. Thread.new is not the correct way to create threads.

Solution

1. Step 1: Analyze variable capture in threads

   The block uses variable i from the loop, which may change before thread runs, causing unexpected output.

2. Step 2: Identify concurrency issue

   Each thread may print the same or wrong i value because i is shared and changes quickly.

3. Final Answer:

   The variable i is shared and may cause unexpected output. -> Option B

4. Quick Check:

   Loop variable shared in threads causes bugs [OK]

Hint: Loop variables shared in threads cause unexpected values [OK]

Common Mistakes:

• Thinking Thread.new is wrong syntax
• Confusing threads.each(&:join) with threads.join
• Assuming syntax error without checking code

5. You want to speed up a Ruby program that downloads many files. Which concurrency approach is best and why?

hard

A. Use a single thread to download files one by one to avoid complexity.

B. Use threads but add sleep calls to slow down downloads.

C. Use multiple processes because Ruby threads cannot run in parallel at all.

D. Use threads to download files concurrently because IO waits can run in parallel.

Solution

1. Step 1: Understand IO-bound tasks and concurrency

   Downloading files is IO-bound and benefits from concurrency because waiting for network is slow.

2. Step 2: Choose concurrency method in Ruby

   Ruby threads can run IO tasks concurrently, improving speed without extra processes.

3. Final Answer:

   Use threads to download files concurrently because IO waits can run in parallel. -> Option D

4. Quick Check:

   Threads speed up IO waits in Ruby [OK]

Hint: Use threads for IO tasks to improve speed [OK]

Common Mistakes:

• Thinking Ruby threads never run in parallel
• Ignoring concurrency benefits for IO tasks
• Adding unnecessary sleep calls