Race condition problem in Operating Systems - Mini Project: Build & Apply

Understanding Race Condition Problem

📖 Scenario: You are learning about how multiple processes or threads can access shared data in a computer system. Sometimes, if they try to change the data at the same time without proper control, it causes unexpected results. This is called a race condition.Imagine two people trying to withdraw money from the same bank account at the same time without knowing about each other. This can cause errors in the balance.

🎯 Goal: Build a simple example that shows how a race condition happens when two processes try to update the same variable without coordination.

📋 What You'll Learn

Create a shared variable representing a bank account balance

Create two separate processes or threads that try to withdraw money

Show how the balance can become incorrect due to race condition

Add a simple control variable to illustrate the problem clearly

💡 Why This Matters

🌍 Real World

Race conditions happen in multitasking computer systems when processes or threads share data without proper synchronization. Understanding this helps prevent bugs in software.

💼 Career

Software developers, system programmers, and testers need to understand race conditions to write safe concurrent programs and avoid data corruption.

1

Create the shared bank account balance

Create a variable called balance and set it to 100 to represent the initial bank account balance.

Operating Systems

# Create the shared bank account balance
# Your code here

Hint

Use a simple variable named balance and assign it the value 100.

2

Create withdrawal amounts for two processes

Create two variables called withdraw1 and withdraw2 and set them to 70 and 50 respectively to represent the amounts two processes want to withdraw.

Operating Systems

balance = 100
# Create withdrawal amounts for two processes
# Your code here

Hint

Use two variables named withdraw1 and withdraw2 with values 70 and 50.

3

Simulate race condition by updating balance without control

Write two lines that subtract withdraw1 and withdraw2 from balance one after the other, simulating two processes withdrawing money without coordination.

Operating Systems

balance = 100
withdraw1 = 70
withdraw2 = 50
# Subtract withdraw1 and withdraw2 from balance without control
# Your code here

Hint

Subtract withdraw1 and then withdraw2 from balance using two separate statements.

4

Add a control variable to illustrate race condition problem

Add a variable called control and set it to False to represent lack of coordination causing the race condition.

Operating Systems

balance = 100
withdraw1 = 70
withdraw2 = 50
balance = balance - withdraw1
balance = balance - withdraw2
# Add a control variable to show race condition
# Your code here

Hint

Use a variable named control and assign it False to show no coordination.

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