GIL (Global Interpreter Lock) impact in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby threading code?

Consider the following Ruby code using threads. What will be printed?

Ruby

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

A 1000

B A number less than 5000

C 5000

D Raises a runtime error

💡 Hint

Think about how Ruby's GIL affects thread execution and shared variable updates.

Because of the GIL, threads do not run Ruby code truly in parallel. However, the increment operation is not atomic, so race conditions occur. This causes the final count to be less than 5000.

🧠 Conceptual

intermediate

Which statement best describes Ruby's GIL impact on CPU-bound threads?

Choose the statement that correctly describes how Ruby's GIL affects CPU-bound threads.

A Ruby's GIL prevents true parallel execution of CPU-bound threads, limiting them to one core at a time.

B Ruby's GIL allows multiple CPU-bound threads to run in parallel on multiple cores.

C Ruby's GIL only affects IO-bound threads, not CPU-bound threads.

D Ruby does not have a GIL, so threads run fully in parallel.

💡 Hint

Consider how the GIL serializes execution of Ruby code.

The GIL ensures only one thread executes Ruby code at a time, so CPU-bound threads cannot run in parallel on multiple cores.

🔧 Debug

advanced

Why does this Ruby code produce inconsistent results with threads?

Examine the code below. Why does the final printed value vary each run?

Ruby

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

A Because the variable 'total' is not thread-safe and increments cause race conditions.

B Because the threads are not properly joined before printing.

C Because the GIL locks the variable 'total' preventing any increments.

D Because Ruby threads run in parallel on multiple cores causing synchronization issues.

💡 Hint

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

The increments on 'total' are not atomic, so race conditions cause inconsistent final values despite the GIL.

📝 Syntax

advanced

Which Ruby code snippet correctly creates threads that safely increment a shared counter?

Choose the code that safely increments a shared counter variable using threads in Ruby.

A

counter = 0
threads = []
3.times do
  threads << Thread.new do
    100.times do
      counter += 1
    end
  end
end
puts counter

B

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

C

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

D

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

💡 Hint

Look for proper use of Mutex to avoid race conditions.

Option D uses a Mutex and synchronizes increments, preventing race conditions. Option D lacks synchronization. Option D uses mutex without defining it. Option D does not join threads before printing.

🚀 Application

expert

How can Ruby programs achieve true parallelism despite the GIL?

Which approach allows Ruby programs to perform true parallel execution despite the GIL?

A Using fibers to switch between tasks cooperatively.

B Using multiple Ruby threads to run CPU-bound tasks concurrently.

C Using multiple processes with inter-process communication instead of threads.

D Disabling the GIL in Ruby interpreter settings.

💡 Hint

Think about how to bypass the GIL's single-thread execution limitation.

Ruby's GIL limits threads to one core at a time. Using multiple processes allows true parallelism because each process has its own interpreter and memory space.