Synchronization in Operating Systems

This set of flashcards covers key vocabulary and concepts related to synchronization in operating systems.

Critical-Section Problem

The challenge of ensuring that multiple processes or threads can safely access shared resources without conflict.

Race Condition

A situation where the outcome of a program depends on the relative timing of events, such as the sequence of execution of threads.

Mutual Exclusion

A principle that ensures that if one process is executing in its critical section, no other process is allowed to enter its critical section.

Progress

A condition that guarantees if no process is executing in its critical section, the selection of the process that will enter the critical section cannot be postponed indefinitely.

Bounded Waiting

A restriction that limits the number of times other processes can enter their critical sections after a request is made.

Mutex Lock

A synchronization primitive that ensures exclusive access to a shared resource by allowing only one process to hold the lock at a time.

Semaphore

An integer variable used for controlling access by multiple processes to a common resource in a concurrent system.

Atomic Variable

A variable that can be read or written without being interrupted, ensuring that operations on it are completed without interference.

Peterson's Solution

A classic algorithm for mutual exclusion for two processes that uses flags and a turn variable to prevent race conditions.

Test-and-Set Instruction

A hardware feature that allows atomic modification of a variable to help implement locks.

Compare-and-Swap Instruction

A hardware instruction that compares the contents of a memory location with a given value and, only if they match, modifies that memory location.

Condition Variable

A synchronization primitive that allows threads to wait until a particular condition holds true.

Monitor

A high-level synchronization construct that allows safe access to shared resources by ensuring only one process executes within a monitor at a time.

Deadlock

A situation where two or more processes are unable to proceed because each is waiting for the other to release resources.

Starvation

A condition where a process is perpetually denied necessary resources to proceed with its work due to resource control mechanisms.

Priority Inversion

A scenario where a lower-priority process holds a resource needed by a higher-priority process, causing the higher-priority process to be blocked.

Signal() Operation

An operation that increments the value of a semaphore, potentially allowing other waiting processes to proceed.

Wait() Operation

An operation that decrements the value of a semaphore and may cause the calling process to block if the value is zero or negative.

Atomic Operation

An operation that is performed as a single, indivisible step, ensuring that no other operations can interleave during its execution.

Entry Section

The part of a process code where a process requests permission to enter the critical section.

Exit Section

The part of a process code where a process releases critical section resources after completing its operation.

Liveness

A property of a concurrent system that guarantees that processes will continue to make progress and will not enter deadlocks.

Kernel Variable

A variable that is used by the operating system kernel to manage resources and processes.

Fork() System Call

A system call used to create a new process by duplicating the calling process.

Asymmetric Solution

A solution strategy where odd and even processes have different protocols for resource acquisition, to avoid deadlocks.

Busy Waiting

A technique where a process repeatedly checks if a condition holds, preventing it from being scheduled to run.

Spoon

A semaphore in the Dining Philosophers Problem representing shared resources between processes (philosophers).

Race Condition Example

Occurs when two threads access and modify a shared variable concurrently without proper synchronization, leading to incorrect outcomes.

Process Termination

The completion of a process or its abnormal end, which can affect synchronization tools and resource management.

Shared Resource

A resource that can be accessed concurrently by multiple processes, requiring synchronization for data integrity.