Why synchronization prevents data corruption in Operating Systems - Quick Recap

Recall & Review

beginner

What is data corruption in the context of concurrent processes?

Data corruption happens when multiple processes or threads try to change the same data at the same time without proper coordination, leading to incorrect or unexpected results.

beginner

What does synchronization mean in operating systems?

Synchronization is a way to control the order in which processes or threads access shared resources to avoid conflicts and ensure data integrity.

beginner

How does synchronization prevent data corruption?

By making sure only one process accesses or changes shared data at a time, synchronization avoids overlapping changes that cause data corruption.

intermediate

What is a critical section in synchronization?

A critical section is a part of the program where shared data is accessed or modified. Synchronization ensures only one process is in this section at a time.

beginner

Name a common synchronization tool used to prevent data corruption.

Mutex (short for mutual exclusion) is a common tool that locks shared data so only one process can use it at a time, preventing data corruption.

What happens if two processes modify shared data simultaneously without synchronization?

A Data corruption may occur

B The system speeds up

C Processes run independently without issues

D Data is automatically backed up

Without synchronization, simultaneous access can cause conflicting changes, leading to data corruption.

Which of the following best describes synchronization?

A Allowing multiple processes to access data at the same time

B Controlling access to shared resources to avoid conflicts

C Speeding up data processing by ignoring conflicts

D Backing up data regularly

Synchronization controls access to shared resources to prevent conflicts and data corruption.

What is a critical section?

A A part of code where shared data is accessed

B A backup area for data

C A process that runs in the background

D A type of data corruption

A critical section is where shared data is accessed or modified, requiring synchronization.

Which synchronization tool locks shared data to prevent simultaneous access?

A Semaphore

B Thread

C Mutex

D Cache

A mutex locks shared data so only one process can access it at a time.

Why is synchronization important in operating systems?

A To allow unlimited access to data

B To slow down processes

C To delete old data

D To prevent data corruption

Synchronization prevents data corruption by managing access to shared data.

Explain in your own words why synchronization is necessary to prevent data corruption.

Think about what happens when two people try to write on the same paper at once.

Describe what a critical section is and how synchronization manages it.

Imagine a single bathroom shared by many people.

Practice

1. Why is synchronization important in operating systems when multiple processes access shared data?

easy

A. It speeds up the execution of all processes by running them simultaneously.

B. It allows processes to ignore each other's data changes.

C. It prevents multiple processes from changing data at the same time, avoiding corruption.

D. It deletes old data automatically to save memory.

Solution

1. Step 1: Understand the problem of concurrent access

   When multiple processes access shared data without control, they can overwrite each other's changes, causing data corruption.

2. Step 2: Role of synchronization

   Synchronization uses locks or similar methods to make sure only one process changes the data at a time, preventing corruption.

3. Final Answer:

   It prevents multiple processes from changing data at the same time, avoiding corruption. -> Option C

4. Quick Check:

   Synchronization stops simultaneous changes = B [OK]

Hint: Synchronization means one at a time access to shared data [OK]

Common Mistakes:

• Thinking synchronization speeds up all processes
• Believing processes can safely ignore each other's changes
• Assuming synchronization deletes data automatically

2. Which of the following is the correct way to use a lock for synchronization in pseudocode?

easy

A. lock.release()
// critical section
lock.acquire()

B. lock.acquire()
// critical section
lock.release()

C. lock.wait()
// critical section
lock.notify()

D. lock.start()
// critical section
lock.stop()

Solution

1. Step 1: Identify correct lock usage

   To protect shared data, a lock must be acquired before entering the critical section and released after finishing.

2. Step 2: Match with options

   lock.acquire() // critical section lock.release() shows acquiring the lock first, then releasing it after the critical section, which is correct.

3. Final Answer:

   lock.acquire() before and lock.release() after critical section -> Option B

4. Quick Check:

   Acquire before, release after = A [OK]

Hint: Acquire lock before, release after critical section [OK]

Common Mistakes:

• Releasing lock before acquiring it
• Using wait/notify instead of acquire/release for locks
• Using start/stop which are not lock methods

3. Consider this pseudocode where two threads increment a shared counter without synchronization:

Thread 1: temp = counter
counter = temp + 1
Thread 2: temp = counter
counter = temp + 1

If both threads read the counter as 0 before either writes back, what is the final value of counter if it started at 0?

medium

A. 1

B. 3

C. 0

D. 2

Solution

1. Step 1: Understand race condition without synchronization

   Both threads read the counter as 0 before either writes back, so both write 1, losing one increment.

2. Step 2: Calculate final counter value

   Instead of 2, the counter ends at 1 because one increment overwrites the other.

3. Final Answer:

   1 -> Option A

4. Quick Check:

   Race condition causes lost update = 1 [OK]

Hint: Without sync, increments can overwrite each other [OK]

Common Mistakes:

• Assuming both increments always add up correctly
• Thinking counter stays 0 without increments
• Expecting counter to be 3 with only two increments

4. This pseudocode tries to synchronize access to a shared variable but still causes data corruption:

lock.acquire()
shared_var = shared_var + 1
// missing lock.release()

What is the main problem here?

medium

A. The shared variable is not incremented correctly.

B. The lock is acquired twice, causing a deadlock.

C. The lock should be acquired after modifying the variable.

D. The lock is never released, causing other processes to wait forever.

Solution

1. Step 1: Identify missing lock release

   The code acquires the lock but never releases it, so other processes cannot enter the critical section.

2. Step 2: Understand effect on synchronization

   This causes a deadlock where other processes wait forever, effectively blocking progress and causing issues.

3. Final Answer:

   The lock is never released, causing other processes to wait forever. -> Option D

4. Quick Check:

   Missing release causes deadlock = C [OK]

Hint: Always release lock after acquiring it [OK]

Common Mistakes:

• Thinking lock acquired twice causes this problem
• Believing variable increment is incorrect here
• Assuming lock should be acquired after modification

5. You have a shared bank account balance accessed by multiple threads. To prevent data corruption, you use synchronization. Which approach best ensures correct balance updates when multiple deposits happen simultaneously?

hard

A. Use a lock to allow only one thread to update the balance at a time.

B. Let all threads update the balance without any lock to improve speed.

C. Use multiple locks for different parts of the balance variable.

D. Update the balance only once at the end without synchronization.

Solution

1. Step 1: Understand the need for exclusive access

   Multiple threads updating the same balance can cause lost updates if they run at the same time.

2. Step 2: Choose synchronization method

   Using a single lock ensures only one thread updates the balance at a time, preventing corruption.

3. Step 3: Evaluate other options

   Allowing no locks risks corruption; multiple locks on parts of balance is complex and error-prone; updating once at end misses intermediate changes.

4. Final Answer:

   Use a lock to allow only one thread to update the balance at a time. -> Option A

5. Quick Check:

   Single lock for exclusive update = A [OK]

Hint: One lock for shared data updates prevents corruption [OK]

Common Mistakes:

• Ignoring synchronization for speed
• Using multiple locks unnecessarily
• Delaying updates without synchronization