Process synchronization is a mechanism used to coordinate the execution of multiple processes or threads that access shared resources, ensuring mutual exclusion, data consistency, and correct ordering of operations.
On the basis of synchronization, processes are categorized into two types:
- Independent Process: The execution of one process does not affect the execution of other processes.
- Cooperative Process: A process that can affect or be affected by other processes executing in the system.
Race Condition and Critical Section
- Race Condition: Occurs when multiple processes access and modify shared data at the same time, so the final result depends on the order of execution.
- Critical Section: The part of a program that accesses shared resources and must run in only one process at a time.
Solutions to Process Synchronization Problems
Solutions to Process Synchronization Problems ensure that only one process is in the critical section at a time. They are broadly categorized into:
- Peterson's Algorithm: A software solution for two processes that uses a flag array and a turn variable to satisfy mutual exclusion, progress, and bounded waiting.
- Dekker's algorithm: The first known correct software solution for two-process mutual exclusion, using flags and a turn variable to decide who enters.
- Bakery Algorithm: A software solution for n processes where each takes a numbered token and the lowest number enters first, like customers in a bakery.
- Hardware Based Solutions: Use atomic hardware instructions, such as Test-and-Set, to achieve mutual exclusion.
Synchronization Tools
- Semaphores: Integer variables accessed only through atomic wait and signal operations to control access to shared resources.
- Difference Between Counting and Binary Semaphores: Compares binary semaphores, limited to 0 or 1 for mutual exclusion, with counting semaphores that manage multiple instances of a resource.
- Mutex vs. Semaphore: Compares a mutex, a lock owned by one process, with a semaphore, a signaling mechanism that can allow several processes in.
- Monitors: A high-level construct that bundles shared data with the procedures that use it, allowing only one process to be active inside at a time.
- Priority Inversion: Occurs when a high-priority process waits for a lock held by a low-priority process that a medium-priority process keeps preempting.
Inter Process Communication
- Inter Process Communication: Mechanisms like shared memory and message passing that let processes exchange data and coordinate their actions.
- Classical IPC Problems: An overview of the standard synchronization problems used to test synchronization solutions.
- Producer-Consumer Problem: Solved using semaphores so the producer waits when the shared buffer is full and the consumer waits when it is empty.
- Readers-Writers Problem: Allows many readers to access shared data together but only one writer at a time, with the readers preference solution favoring readers.
- Dining Philosophers Problem: Five philosophers share forks and need two to eat, requiring a scheme that avoids deadlock and starvation.
