Why synchronization prevents data corruption in Operating Systems - See It in Action

Why synchronization prevents data corruption

📖 Scenario: Imagine two friends sharing a notebook to write their daily expenses. Without taking turns, they might write on the same page at the same time, causing confusion and mistakes.

🎯 Goal: Build a simple example that shows how synchronization helps prevent data corruption when two processes try to update the same data.

📋 What You'll Learn

Create a shared variable called balance with an initial value of 100

Create a variable called withdraw_amount set to 30

Write a function called withdraw that subtracts withdraw_amount from balance

Add a synchronization mechanism to ensure only one withdrawal happens at a time

💡 Why This Matters

🌍 Real World

Synchronization is used in banking systems, ticket booking, and any place where multiple users access shared data.

💼 Career

Understanding synchronization is essential for software developers, system administrators, and anyone working with concurrent or parallel systems.

1

Set up the shared data

Create a variable called balance and set it to 100.

Operating Systems

# Create a variable called balance and set it to 100
# Your code here

Need a hint?

Think of balance as the notebook where both friends write their expenses.

2

Add the withdrawal amount

Create a variable called withdraw_amount and set it to 30.

Operating Systems

balance = 100
# Create a variable called withdraw_amount and set it to 30
# Your code here

Need a hint?

This is the amount each friend wants to take from the shared money.

3

Write the withdrawal function

Write a function called withdraw that subtracts withdraw_amount from balance.

Operating Systems

balance = 100
withdraw_amount = 30
# Define a function withdraw that subtracts withdraw_amount from balance
# Your code here

Need a hint?

This function simulates one friend taking money from the shared balance.

4

Add synchronization to prevent data corruption

Import threading, create a Lock called lock, and modify the withdraw function to use lock.acquire() before subtracting and lock.release() after.

Operating Systems

balance = 100
withdraw_amount = 30
import threading
lock = threading.Lock()

def withdraw():
    global balance
    # Use lock to prevent simultaneous access
    # Your code here

Need a hint?

Using a lock is like taking turns to write in the notebook, so no one writes at the same time.