Race condition problem in Operating Systems - Step-by-Step Execution

Concept Flow - Race condition problem

Start: Two processes want to access shared data

↓

Process 1 reads data

↓

Both processes modify data independently

↓

Process 1 writes data back

↓

Data overwritten, inconsistent state

↓

Race condition occurs

Two or more processes access and modify shared data at the same time without proper coordination, causing unexpected results.

Execution Sample

Operating Systems

SharedCounter = 0
Process1: temp = SharedCounter
Process1: temp = temp + 1
Process2: temp = SharedCounter
Process2: temp = temp + 1
Process1: SharedCounter = temp
Process2: SharedCounter = temp

Two processes read, increment, and write back a shared counter without synchronization, causing a race condition.

Analysis Table

Step	Process	Action	SharedCounter Before	Temp Value	SharedCounter After
1	Process1	Read SharedCounter	0	0	0
2	Process1	Increment temp	0	1	0
3	Process2	Read SharedCounter	0	0	0
4	Process2	Increment temp	0	1	0
5	Process1	Write temp to SharedCounter	0	1	1
6	Process2	Write temp to SharedCounter	0	1	1

💡 Both processes wrote '1' causing the counter to increase only once instead of twice, showing a race condition.

State Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6
SharedCounter	0	0	0	0	0	1	1
Process1_temp	N/A	0	1	1	1	1	1
Process2_temp	N/A	N/A	N/A	0	1	1	1

Key Insights - 3 Insights

Why does the SharedCounter only increase by 1 instead of 2?

Because both processes read the same initial value before either writes back, they overwrite each other's updates as shown in steps 5 and 6 of the execution_table.

Why is it a problem that both processes read SharedCounter before writing?

Reading before writing without coordination means each process works with stale data, causing lost updates as seen in steps 3 and 4.

How does this relate to the term 'race condition'?

The processes 'race' to write their changes, and the final result depends on who writes last, leading to unpredictable and incorrect outcomes.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of SharedCounter after step 5?

A 2

B 0

C 1

D Undefined

💡 Hint

Check the 'SharedCounter After' column at step 5 in the execution_table.

At which step does Process2 read the SharedCounter value?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for Process2's 'Read SharedCounter' action in the execution_table.

If Process1 wrote to SharedCounter before Process2 read it, what would be the SharedCounter value after step 6?

A 2

B 0

C 1

D Cannot determine

💡 Hint

Consider the order of writes and reads in the execution_table and how it affects the final value.

Concept Snapshot

Race condition occurs when multiple processes access and modify shared data simultaneously without coordination.
This causes unpredictable results because updates can overwrite each other.
Example: Two processes incrementing a shared counter without synchronization may lose one increment.
To prevent this, use locks or synchronization methods to control access.

Full Transcript

A race condition problem happens when two or more processes try to use the same data at the same time without proper control. For example, if two processes read a shared counter as zero, both add one, and then both write back, the counter only increases once instead of twice. This happens because the second process overwrites the first process's update. The execution table shows each step: both processes read zero, increment their own copy, then write back one. The final shared counter is one, not two. This is a race condition because the processes race to write their changes, and the last write wins, causing lost updates. To avoid this, processes must coordinate using locks or other synchronization tools to ensure only one process changes the data at a time.

Practice

1. What is a race condition in operating systems?

easy

A. When multiple processes access shared data simultaneously without proper control

B. When a process runs slower than expected

C. When a program crashes due to memory overflow

D. When a system runs out of disk space

Solution

1. Step 1: Understand the definition of race condition

   A race condition occurs when two or more processes access shared data at the same time without synchronization.

2. Step 2: Identify the correct description

   When multiple processes access shared data simultaneously without proper control correctly describes this situation, while others describe unrelated problems.

3. Final Answer:

   When multiple processes access shared data simultaneously without proper control -> Option A

4. Quick Check:

   Race condition = simultaneous uncontrolled access [OK]

Hint: Look for simultaneous access without control [OK]

Common Mistakes:

• Confusing race condition with system crashes
• Thinking it relates to disk space issues
• Mixing it up with slow process execution

2. Which of the following is a common method to prevent race conditions?

easy

A. Running processes sequentially without any synchronization

B. Using locks or mutexes to control access

C. Deleting shared data

D. Increasing CPU speed

Solution

1. Step 1: Identify synchronization methods

   Locks and mutexes are tools used to control access to shared data and prevent race conditions.

2. Step 2: Evaluate other options

   Increasing CPU speed or deleting data does not prevent race conditions. Running processes sequentially without synchronization is unsafe.

3. Final Answer:

   Using locks or mutexes to control access -> Option B

4. Quick Check:

   Locks prevent race conditions [OK]

Hint: Choose synchronization tools like locks [OK]

Common Mistakes:

• Thinking faster CPU fixes race conditions
• Ignoring the need for synchronization
• Assuming deleting data helps

3. Consider two processes incrementing a shared counter without locks. What is the likely outcome?

medium

A. The system will throw a syntax error

B. The counter will always increase correctly by 2

C. The counter will reset to zero automatically

D. The counter might increase incorrectly due to overlapping updates

Solution

1. Step 1: Understand concurrent increments without locks

   Without locks, both processes may read the same value before incrementing, causing lost updates.

2. Step 2: Identify the effect on the counter

   This leads to the counter increasing incorrectly, not by the expected total increments.

3. Final Answer:

   The counter might increase incorrectly due to overlapping updates -> Option D

4. Quick Check:

   Race condition causes incorrect increments [OK]

Hint: Look for overlapping updates causing errors [OK]

Common Mistakes:

• Assuming increments always add correctly
• Expecting syntax errors from concurrency
• Thinking counter resets automatically

4. Given this code snippet, what is the main problem causing a race condition?

shared_counter = 0

process1() {
  temp = shared_counter
  temp = temp + 1
  shared_counter = temp
}

process2() {
  temp = shared_counter
  temp = temp + 1
  shared_counter = temp
}

medium

A. The increment operation is atomic and safe

B. The variable shared_counter is not declared

C. Both processes read and write shared_counter without synchronization

D. The processes run sequentially

Solution

1. Step 1: Analyze access to shared_counter

   Both processes read, modify, and write shared_counter without any locks or synchronization.

2. Step 2: Identify the race condition cause

   This unsynchronized access can cause lost updates because the operations are not atomic.

3. Final Answer:

   Both processes read and write shared_counter without synchronization -> Option C

4. Quick Check:

   Unsynchronized access causes race condition [OK]

Hint: Check if shared data access is synchronized [OK]

Common Mistakes:

• Assuming increment is atomic
• Ignoring synchronization needs
• Thinking variables must be declared explicitly

5. Two threads update a shared bank account balance without locks. Thread A reads balance $100, adds $50, Thread B reads balance $100, subtracts $30. What is the possible incorrect final balance due to race condition?

hard

A. $150

B. $120

C. $130

D. $180

Solution

1. Step 1: Understand the operations without synchronization

   Thread A reads 100, plans to write 150; Thread B reads 100, plans to write 70.

2. Step 2: Identify race condition effect

   If Thread A writes 150, then Thread B overwrites with 70, or vice versa, one update is lost. If both read 100 before writing, possible final balances are 150 or 70, both incorrect (expected sequential: 120).

3. Step 3: Calculate possible incorrect final balance

   For example, if Thread B writes 70 first, then Thread A writes 150, final balance is $150 (lost B's update).

4. Final Answer:

   $150 -> Option A

5. Quick Check:

   Race condition causes incorrect balance $150 [OK]

Hint: Check if updates overwrite each other without locks [OK]

Common Mistakes:

• Assuming both updates always apply correctly
• Ignoring lost update problem
• Confusing addition and subtraction effects