Operating Systems Concurrency Concepts Quiz

Concurrency allows multiple threads to execute simultaneously, which introduces shared resource access issues. Some resources such as variables, files, or memory locations cannot be safely accessed by more than one thread at the same time. Without proper synchronization, this can lead to race conditions, data corruption, and inconsistent program states.

A critical section must be accessed by only one thread at a time to preserve data integrity. Allowing multiple threads to execute inside it simultaneously can result in inconsistent or corrupted shared data. Mutual exclusion ensures safe access and prevents race conditions.

Mutual exclusion is a fundamental synchronization concept that guarantees only one thread can enter a critical section at any given moment. This restriction prevents concurrent modification of shared resources and ensures predictable and correct program behavior in multi-threaded systems.

Spin-locks repeatedly check for lock availability without yielding the CPU. While waiting, the thread consumes processor time but does no useful work. This wastes CPU cycles and reduces overall system efficiency, especially when wait times are long.

Peterson’s Solution is designed for exactly two threads that share memory. It relies on shared variables and assumes strict memory ordering. These constraints limit its applicability in modern multiprocessor systems and prevent scaling beyond two threads.

Peterson’s Solution involves busy waiting, where threads repeatedly check conditions instead of sleeping. This continuous checking consumes CPU time unnecessarily and makes the algorithm inefficient despite providing correct mutual exclusion.

Without priorities or queuing, spin-locks can allow some threads to repeatedly acquire the lock while others wait indefinitely. This unfairness can cause starvation, especially when scheduling favors certain threads consistently.

Deadlock occurs when threads wait indefinitely for resources held by each other. None of the threads can proceed, resulting in a complete system halt unless external intervention resolves the circular wait.

Busy waiting is inefficient because it occupies the CPU without performing productive work. Instead of yielding control, the thread repeatedly checks a condition, reducing CPU availability for other useful processes.

Atomic instructions ensure that certain operations complete without interruption. This hardware guarantee is essential for implementing reliable synchronization mechanisms such as locks and semaphores in concurrent systems.

The bakery algorithm generalizes mutual exclusion beyond two threads by assigning ordering numbers. This ensures fair, ordered access to the critical section and avoids starvation, making it suitable for multiple-thread environments.

A race condition occurs when program behavior depends on the timing or interleaving of threads. Since thread scheduling is controlled by the operating system and hardware, programmers cannot predict execution order. This unpredictability can cause different results each time the program runs, even with the same input.

Starvation occurs when a thread is perpetually denied access to a resource. In mutual exclusion, this often happens due to low priority scheduling or unfair lock acquisition policies. Some threads may wait indefinitely while others repeatedly gain access.

In naive lock implementations, checking and setting the lock are separate operations. If a thread is preempted between these steps, another thread can acquire the lock first. This race condition breaks mutual exclusion and allows multiple threads into the critical section.

The bakery algorithm assigns each thread a number when requesting access to a critical section. Threads are served in increasing order of these numbers, ensuring fairness. Appending process IDs resolves ties, making the ordering deterministic and starvation-free.

Raising the interrupt priority level prevents the running thread from being preempted while testing and setting the lock. This removes the gap where another thread could interfere, ensuring atomicity during the critical lock acquisition sequence.

Test-and-Set is a hardware-supported atomic instruction that simultaneously reads and sets a lock variable. Its indivisible nature prevents other threads from interrupting the operation, ensuring safe mutual exclusion even on multiprocessor systems.

Introducing priorities in spin-locks allows high-priority threads to acquire locks first. While this improves responsiveness for critical tasks, it increases the risk of indefinite postponement for lower-priority threads.

Livelock happens when threads continuously change their state in response to each other but make no actual progress. Unlike deadlock, threads are active, but useful work never occurs due to constant state changes.

Interrupt priority levels are heavy-handed because they stop all lower-priority processes, even those not involved in synchronization. On multiprocessor systems, coordination overhead increases as all processors must honor the priority change.