Why synchronization prevents data corruption in Operating Systems - Visual Breakdown

Concept Flow - Why synchronization prevents data corruption

Multiple processes want to access shared data

↓

Without synchronization: concurrent access

↓

Race condition occurs

↓

Data corruption happens

↓

With synchronization: access controlled

↓

Only one process accesses data at a time

↓

No race condition

↓

Data remains consistent and correct

This flow shows how unsynchronized access leads to data corruption due to race conditions, while synchronization controls access to keep data safe.

Execution Sample

Operating Systems

shared_data = 0

# Process 1
temp = shared_data
temp = temp + 1
shared_data = temp

# Process 2
temp = shared_data
temp = temp + 1
shared_data = temp

Two processes try to increment the same shared data without synchronization, which can cause incorrect final values.

Analysis Table

Step	Process	Action	shared_data Before	temp Value	shared_data After	Notes
1	Process 1	Read shared_data	0	0	0	Process 1 reads 0
2	Process 2	Read shared_data	0	0	0	Process 2 reads 0 before Process 1 writes
3	Process 1	Increment temp	0	1	0	temp becomes 1
4	Process 2	Increment temp	0	1	0	temp becomes 1 independently
5	Process 1	Write shared_data	0	1	1	shared_data updated to 1
6	Process 2	Write shared_data	1	1	1	shared_data overwritten to 1, lost increment
7	End	-	1	-	1	Final shared_data is 1, should be 2
8	With synchronization	Process 1 completes fully before Process 2 starts	0	-	2	No data corruption, final value correct

💡 Without synchronization, both processes read 0 and write 1, causing data corruption. Synchronization ensures one process finishes before the other starts.

State Tracker

Variable	Start	After Step 1	After Step 2	After Step 5	After Step 6	Final
shared_data	0	0	0	1	1	1
temp (P1)	-	0	-	1	-	-
temp (P2)	-	-	0	-	1	-

Key Insights - 2 Insights

Why does shared_data end up as 1 instead of 2 without synchronization?

Because both processes read the initial value 0 before either writes back, they both increment 0 to 1 independently, and the last write overwrites the first, losing one increment (see execution_table steps 2, 5, 6).

How does synchronization prevent the race condition?

Synchronization makes sure one process completes reading, incrementing, and writing before the other starts, so the second process reads the updated value, preventing lost updates (see execution_table step 8).

Visual Quiz - 3 Questions

Look at the execution_table at step 6. What happens to shared_data?

A It is overwritten to 1, losing one increment.

B It remains 0 because no write happened.

C It is updated to 2 correctly.

D It causes an error and stops execution.

💡 Hint

Check the 'shared_data After' column at step 6 and note the value compared to step 5.

At which step does Process 1 write the updated value to shared_data?

A Step 3

B Step 5

C Step 2

D Step 6

💡 Hint

Look at the 'Action' column for Process 1 writing shared_data.

If synchronization is added, what will be the final value of shared_data?

A 0

B 1

C 2

D Undefined

💡 Hint

Refer to the last row in execution_table describing synchronized execution.

Concept Snapshot

When multiple processes access shared data at the same time without control, they can overwrite each other's changes, causing data corruption.
Synchronization ensures only one process accesses the data at a time.
This prevents race conditions and keeps data consistent.
Common synchronization tools include locks, semaphores, and monitors.
Always synchronize shared data access in concurrent systems.

Full Transcript

This visual execution trace shows why synchronization prevents data corruption. Two processes try to increment the same shared data variable without synchronization. Both read the initial value 0, increment it to 1 independently, and write back 1. The second write overwrites the first, so the final value is 1 instead of 2, causing data corruption. Synchronization forces one process to complete its read-increment-write cycle before the other starts, preventing lost updates and ensuring the final value is correct. Key moments include understanding how race conditions cause lost updates and how synchronization avoids them. The quiz questions reinforce these points by referencing specific steps in the execution table.