critical section - TarisMajor/5143-OpSystems GitHub Wiki

Critical Section refers to a segment of code in a process where shared resources (such as variables, data structures, or hardware devices) are accessed and modified. Because these resources are shared among multiple processes or threads, proper synchronization is required to prevent concurrent access, which can lead to data inconsistency or corruption.

1. Exclusive Access: Only one process or thread can execute within the critical section at any given time, ensuring exclusive access to the shared resources.
2. Synchronization Mechanisms: Mechanisms such as locks, semaphores, and monitors are used to synchronize access to the critical section, preventing race conditions and ensuring data integrity.
3. Atomicity: The operations within a critical section are performed atomically, meaning they are completed without interruption.

1. Data Consistency: Ensures that shared resources are accessed and modified in a consistent and controlled manner, preventing data corruption.
2. Concurrency Control: Critical sections are essential for managing concurrent execution of processes and threads, ensuring that they do not interfere with each other.
3. System Stability: Proper use of critical sections contributes to the overall stability and reliability of the system by preventing race conditions and deadlocks.

1. Mutex (Mutual Exclusion Object): A mutex is a synchronization primitive that ensures mutual exclusion by allowing only one process or thread to acquire the lock and enter the critical section at a time. Other processes or threads must wait until the lock is released.
2. Semaphore: A semaphore is a synchronization primitive that can control access to a resource by multiple processes or threads. It can have a counter to allow a limited number of concurrent accesses.
3. Monitor: A monitor is a high-level synchronization construct that combines mutual exclusion and condition variables. It allows processes or threads to wait for certain conditions to be met before entering the critical section.

The critical section problem involves designing a protocol that ensures the following conditions are met when multiple processes or threads attempt to enter their critical sections:

1. Mutual Exclusion: Only one process or thread can be in its critical section at a time.
2. Progress: If no process is in its critical section, and there are processes that wish to enter, one of them should be allowed to enter without unnecessary delay.
3. Bounded Waiting: There must be a limit on the number of times other processes can enter their critical sections after a process has made a request to enter its critical section and before the requesting process is granted access.

1. Peterson's Algorithm: A classical solution for two-process synchronization that uses two shared variables to ensure mutual exclusion and progress.
2. Bakery Algorithm: A general solution for multiple processes that uses a numbering scheme to ensure that each process is granted access to the critical section in the order of their request.
3. Hardware Support: Modern systems often use hardware instructions like Test-and-Set or Compare-and-Swap to implement efficient synchronization mechanisms.

• Operating System Concepts by Abraham Silberschatz, Peter B. Galvin, and Greg Gagne
• Critical Section Problem - GeeksforGeeks
• Modern Operating Systems by Andrew S. Tanenbaum
• Wikipedia - Critical Section
• ChatGPT