GIL (Global Interpreter Lock) impact in Ruby - Mini Project: Build & Apply

Understanding GIL (Global Interpreter Lock) Impact in Ruby

📖 Scenario: You are working on a Ruby program that needs to perform multiple tasks at the same time. You want to see how Ruby's Global Interpreter Lock (GIL) affects running threads concurrently.

🎯 Goal: Build a simple Ruby program that creates multiple threads to count numbers. You will observe how GIL impacts the execution of these threads.

📋 What You'll Learn

Create a variable to hold a shared counter

Create a variable to hold the number of threads

Create multiple threads that increment the shared counter

Print the final value of the shared counter

💡 Why This Matters

🌍 Real World

Understanding GIL helps developers write better concurrent Ruby programs, especially when working with threads for tasks like web servers or background jobs.

💼 Career

Many Ruby developer roles require knowledge of threading and concurrency to optimize application performance and avoid bugs related to shared data.

1

Create a shared counter variable

Create a variable called counter and set it to 0.

Ruby

# Your code here

Need a hint?

Use a simple variable assignment to start the counter at zero.

2

Set the number of threads

Create a variable called thread_count and set it to 5.

Ruby

counter = 0
# Your code here

Need a hint?

Use a variable to store how many threads you want to create.

3

Create threads to increment the counter

Create an array called threads and use a thread_count.times do |i| ... end loop to create threads. Each thread should increment counter 1000 times using counter += 1.

Ruby

counter = 0
thread_count = 5
# Your code here

Need a hint?

Create threads inside a loop and make each thread add 1 to the counter 1000 times. Use threads.each(&:join) to wait for all threads to finish.

4

Print the final counter value

Write puts counter to display the final value of counter after all threads finish.

Ruby

counter = 0
thread_count = 5
threads = []
thread_count.times do |i|
  threads << Thread.new do
    1000.times do
      counter += 1
    end
  end
end
threads.each(&:join)
# Your code here

Need a hint?

Use puts counter to print the final count after all threads complete.