Process Synchronization

1. Introduction to Process Synchronization

Process synchronization ensures that multiple processes or threads execute in a way that maintains data integrity and avoids race conditions when accessing shared resources.

💡 Why is Process Synchronization Needed?

• In multiprocessing environments, multiple processes execute concurrently.
• If they share resources (e.g., memory, files, databases), data inconsistency may occur.
• Example: Two threads modifying a bank account balance simultaneously may lead to incorrect results.

---

2. Race Condition

A race condition occurs when multiple processes or threads access shared data simultaneously, leading to unpredictable results.

✔ Example of Race Condition:

• Process A reads a bank balance of $1000.
• Process B reads the same balance ($1000) and withdraws $200.
• Process A withdraws $500 and updates the balance ($500 instead of $300!)

💡 To prevent race conditions, process synchronization mechanisms are required!

---

3. Critical Section Problem

The Critical Section is a code segment where a shared resource is accessed. Only one process should enter the critical section at a time to maintain consistency.

📌 Four Conditions for a Good Synchronization Solution

1. Mutual Exclusion → Only one process at a time should be in the critical section.
2. Progress → If no process is in the critical section, others should be allowed to enter.
3. Bounded Waiting → A process should not wait indefinitely.
4. No Deadlock or Starvation → Processes should not be stuck forever.

---

4. Synchronization Mechanisms

📌 1. Locks (Mutex Locks)

✅ A lock is a mechanism that allows only one process to access the critical section at a time.
✅ If a process locks a resource, others must wait until it is released.

✔ Example:

cCopyEditlock();  // Acquire lock
// Critical section (shared resource access)
unlock(); // Release lock

🚀 Advantage: Simple and effective.
⚠ Disadvantage: Can lead to deadlock if not handled properly.

---

📌 2. Semaphores

✅ A semaphore is a synchronization variable that controls access to shared resources.
✅ It can be binary (0 or 1) or counting (any integer value).

✔ Example (Binary Semaphore – Mutex)

cCopyEditwait(S);  // Decrease semaphore (lock)
Critical Section
signal(S); // Increase semaphore (unlock)

🚀 Advantage: Prevents race conditions efficiently.
⚠ Disadvantage: Complex implementation; may cause deadlocks.

---

📌 3. Monitors

✅ A high-level synchronization mechanism that provides automatic mutual exclusion.
✅ Used in programming languages like Java (synchronized methods/blocks).

✔ Example (Java Monitor)

javaCopyEditsynchronized void criticalSection() {
   // Only one thread can execute this
}

🚀 Advantage: Easier to use than semaphores.
⚠ Disadvantage: Only works with object-oriented programming languages.

---

5. Classical Synchronization Problems

Problem	Description	Solution
Producer-Consumer Problem	One process produces items while another consumes them.	Use semaphores to ensure proper synchronization.
Readers-Writers Problem	Multiple readers can read a file, but only one writer can write at a time.	Use reader-writer locks or semaphores.
Dining Philosophers Problem	Five philosophers share five forks; they must avoid deadlocks while eating.	Use semaphores, monitors, or deadlock prevention techniques.

---

6. Deadlocks and Starvation

📌 Deadlock

• Occurs when two or more processes are waiting for resources indefinitely.
• Example: Process A locks Resource 1, Process B locks Resource 2, both wait for each other.

💡 Solution:

• Avoid circular waiting (one-at-a-time resource allocation).
• Use timeouts or resource ordering.

---

📌 Starvation

• A low-priority process never gets scheduled due to high-priority processes always executing first.

💡 Solution:

• Use priority aging (gradually increase waiting process priority).

---

7. Conclusion

✔ Process synchronization is essential in multi-processing environments to prevent race conditions and maintain data integrity.
✔ Locks, Semaphores, and Monitors are key synchronization mechanisms.
✔ Common problems like Producer-Consumer and Readers-Writers can be solved using these mechanisms.
✔ Deadlocks and Starvation must be handled carefully to ensure system performance.