Thread safety concepts in Ruby - Step-by-Step Execution

Concept Flow - Thread safety concepts

Start Thread 1

↓

Access shared data

↓

Modify shared data

↓

Race condition?

↓

Data corrupted

↓

End

Two threads try to access and modify shared data at the same time, which can cause conflicts unless controlled.

Execution Sample

Ruby

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

This code starts 5 threads, each adding 1 to a shared counter 1000 times, then prints the final counter value.

Execution Table

Step	Thread	Action	counter before	counter after	Note
1	T1	Read counter	0	0	Reads current counter value 0
2	T1	Add 1	0	1	Adds 1 to local value
3	T2	Read counter	0	0	Reads counter before T1 writes
4	T1	Write counter	0	1	Writes updated counter 1
5	T2	Add 1	0	1	Adds 1 to local value
6	T2	Write counter	0	1	Overwrites counter with 1, lost increment
...	...	...	...	...	...
Final	All	After all increments	?	less than 5000	Counter less than expected due to race conditions

💡 Threads finish but counter is less than 5000 because increments overlapped and some were lost.

Variable Tracker

Variable	Start	After T1 step 2	After T2 step 6	Final
counter	0	1	1	<5000 (less than expected)

Key Moments - 3 Insights

Why does the counter end up less than 5000 even though 5 threads add 1000 each?

Because threads read and write the counter at the same time without coordination, some increments overwrite others. See execution_table steps 3-6 where T2 reads before T1 writes, causing lost updates.

What is a race condition in this example?

A race condition happens when multiple threads access and modify shared data without proper control, leading to unpredictable results. Here, threads race to update 'counter' causing incorrect final value.

How can we fix this problem?

By using synchronization tools like Mutex to make sure only one thread changes 'counter' at a time, preventing overlapping updates.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'counter' after Thread 2 writes in step 6?

A 1

B 0

C 2

D 1000

💡 Hint

Check the 'counter after' column in step 6 of execution_table.

At which step does the race condition cause a lost increment?

A Step 2

B Step 4

C Step 6

D Final

💡 Hint

Look at when Thread 2 overwrites the counter without adding its increment properly (step 6).

If we add a Mutex lock around the increment, how would the final counter value change?

A It would be less than 5000

B It would be exactly 5000

C It would be zero

D It would be random

💡 Hint

Mutex prevents race conditions, so all increments count correctly, see key_moments answer 3.

Concept Snapshot

Thread safety means controlling access to shared data
Without control, threads can overwrite each other (race condition)
Use Mutex or locks to allow one thread at a time
This prevents lost updates and data corruption
Always protect shared variables in multithreaded code

Full Transcript

This example shows two or more threads trying to update the same variable 'counter' at the same time. Because they read and write without waiting for each other, some increments get lost. This is called a race condition. The execution table traces how Thread 1 reads and writes the counter, then Thread 2 reads the old value before Thread 1 writes, causing Thread 2 to overwrite the update. The final counter is less than expected. To fix this, we use a Mutex lock so only one thread changes the counter at a time, ensuring the final count is correct. Thread safety is about preventing these conflicts when multiple threads share data.

Practice

1. What is the main purpose of thread safety in Ruby programs?

easy

A. To make the program run slower

B. To prevent errors when multiple threads access shared data

C. To allow threads to run without any synchronization

D. To avoid using threads altogether

Solution

1. Step 1: Understand thread safety concept

   Thread safety means making sure multiple threads do not cause errors when they access the same data.

2. Step 2: Identify the main goal

   The main goal is to prevent errors and data corruption when threads run at the same time.

3. Final Answer:

   To prevent errors when multiple threads access shared data -> Option B

4. Quick Check:

   Thread safety = prevent errors [OK]

Hint: Thread safety means safe shared data access [OK]

Common Mistakes:

• Thinking thread safety slows down programs
• Believing threads never need synchronization
• Confusing thread safety with avoiding threads

2. Which Ruby code snippet correctly uses a Mutex to protect a shared variable counter?

easy

A. mutex.synchronize { counter += 1 }

B. mutex.lock { counter += 1 }

C. mutex.unlock { counter += 1 }

D. mutex.wait { counter += 1 }

Solution

1. Step 1: Recall Mutex usage in Ruby

   Mutex uses the synchronize method to safely run code blocks.

2. Step 2: Check each option

   Only mutex.synchronize { ... } is the correct syntax to lock and unlock automatically.

3. Final Answer:

   mutex.synchronize { counter += 1 } -> Option A

4. Quick Check:

   Mutex uses synchronize method [OK]

Hint: Use synchronize to lock Mutex safely [OK]

Common Mistakes:

• Using lock or unlock methods incorrectly
• Trying to pass a block to lock or unlock
• Confusing wait with Mutex methods

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

require 'thread'
mutex = Mutex.new
counter = 0
threads = 5.times.map do
  Thread.new do
    10.times do
      mutex.synchronize { counter += 1 }
    end
  end
end
threads.each(&:join)
puts counter

medium

A. 10

B. 0

C. 5

D. 50

Solution

1. Step 1: Analyze thread and loop counts

   There are 5 threads, each incrementing counter 10 times, total increments = 5 * 10 = 50.

2. Step 2: Understand Mutex protection

   Mutex ensures increments happen safely without lost updates, so counter will be exactly 50.

3. Final Answer:

   50 -> Option D

4. Quick Check:

   5 threads * 10 increments = 50 [OK]

Hint: Multiply threads by increments with Mutex [OK]

Common Mistakes:

• Ignoring Mutex and expecting less than 50
• Confusing thread count with increments
• Assuming race conditions reduce count

4. Identify the problem in this Ruby code that uses threads:

counter = 0
threads = 3.times.map do
  Thread.new do
    100.times { counter += 1 }
  end
end
threads.each(&:join)
puts counter

medium

A. Thread.new syntax is incorrect

B. Threads are not joined, so program ends early

C. No Mutex used, so race condition may cause wrong counter value

D. Counter variable is not initialized

Solution

1. Step 1: Check thread safety of counter increment

   Multiple threads increment counter without synchronization, causing race conditions.

2. Step 2: Identify missing Mutex usage

   Without Mutex, increments can overlap and produce incorrect final value.

3. Final Answer:

   No Mutex used, so race condition may cause wrong counter value -> Option C

4. Quick Check:

   Missing Mutex causes race condition [OK]

Hint: Always use Mutex to protect shared variables [OK]

Common Mistakes:

• Thinking threads are not joined (they are)
• Assuming counter needs initialization (it is initialized)
• Believing Thread.new syntax is wrong

5. You want to safely update a shared hash results from multiple threads in Ruby. Which approach correctly ensures thread safety?

hard

A. Use a Mutex and wrap all results[key] = value assignments inside mutex.synchronize

B. Use Thread.new without any synchronization because Ruby hashes are thread-safe

C. Create a new hash inside each thread and merge them later without synchronization

D. Use sleep to delay threads and avoid conflicts

Solution

1. Step 1: Understand thread safety for shared hashes

   Ruby hashes are not thread-safe for writes; concurrent writes can cause errors or data loss.

2. Step 2: Use Mutex to protect hash updates

   Wrapping assignments inside mutex.synchronize ensures only one thread writes at a time.

3. Final Answer:

   Use a Mutex and wrap all results[key] = value assignments inside mutex.synchronize -> Option A

4. Quick Check:

   Mutex protects shared hash writes [OK]

Hint: Protect shared hash writes with Mutex synchronize [OK]

Common Mistakes:

• Assuming Ruby hashes are thread-safe for writes
• Using sleep to avoid conflicts (not reliable)
• Merging hashes without synchronization risks data loss