Module 2: Concurrency and Synchronization

Vocabulary flashcards covering core concepts, definitions, and synchronization mechanisms from Module 2: Concurrency and Synchronization.

Process

A program that is currently being executed, provided by the operating system with resources such as memory, CPU time, file handles, input/output resources, and system resources, typically possessing its own independent address space.

Thread

A lightweight unit of execution within a process that shares memory with other threads in the same process and has its own execution state.

Concurrency

The ability of multiple tasks to make progress during overlapping periods by switching execution, which does not necessarily mean tasks execute at the exact same instant.

Parallelism

The simultaneous execution of multiple tasks at the exact same time, typically using multiple processing units or CPU cores.

Throughput

The total amount of material, data, or work that a system handles, processes, or produces within a specific period of time, measuring real operational capacity and speed.

Shared Resource

A resource, such as shared variables, databases, files, memory locations, printers, network connections, counters, or queues, that can be accessed by multiple processes or threads.

Race Condition

A flaw that occurs when the result of a program depends on the timing or order in which concurrent tasks execute while competing to access or modify shared data.

Lost Update

A specific outcome of a race condition where concurrent write operations overwrite each other, causing one thread's update to be lost.

Critical Section

A portion of a program where a shared resource is accessed or modified, requiring careful control when accessible by multiple threads.

Critical Section Problem

The problem that arises when multiple processes or threads attempt to access the critical section simultaneously, potentially causing race conditions.

Mutual Exclusion

A synchronization requirement and principle ensuring that only one process or thread can enter or access a particular critical section or resource at a time.

Progress

A critical section requirement stating that if no process is inside the critical section, a process ready to enter should not be unnecessarily prevented from doing so.

Bounded Waiting

A critical section requirement stating that a process should not wait indefinitely to enter the critical section.

Deadlock

A state in which two or more processes or threads become permanently blocked because each is waiting for a resource held by another.

Hold and Wait

One of the four necessary conditions for deadlock, occurring when a process holds at least one resource while waiting to acquire another resource held by another process.

No Preemption

One of the four necessary conditions for deadlock, specifying that a resource cannot be forcibly taken away from a process; it must be released voluntarily by the process holding it.

Circular Wait

One of the four necessary conditions for deadlock, in which a closed chain of processes exists where each process waits for a resource held by another process in the cycle.

Deadlock Prevention

Methods used to prevent deadlocks by ensuring that at least one of the four necessary conditions for deadlock cannot hold.

Deadlock Avoidance

A strategy that dynamically makes resource-allocation decisions to keep the system in a safe state and prevent deadlock.

Banker's Algorithm

A well-known deadlock avoidance algorithm used to determine whether granting a resource request could potentially lead to an unsafe state or deadlock.

Deadlock Detection and Recovery

A strategy where a system allows deadlocks to occur, detects them, and recovers by terminating processes, releasing resources, preempting resources, or restarting operations.

Synchronization

Techniques used to coordinate concurrent processes or threads so that they access shared resources safely and execute in an appropriate order.

Lock

A synchronization mechanism used to control access to a shared resource, requiring other threads to wait while one thread holds ownership.

Mutex

A mutual exclusion lock specifically designed to ensure that only one thread enters a protected critical section at a time.

Semaphore

A synchronization mechanism that uses a counter to control access to shared resources for one or multiple threads.

Binary Semaphore

A semaphore with two possible states (0 for unavailable, 1 for available) used to control access to a shared resource.

Counting Semaphore

A semaphore that uses a non-negative counter to represent and manage multiple available instances of a resource.

Monitor

A higher-level synchronization construct that combines shared data, operations accessing the data, and synchronization mechanisms so that only one thread executes inside at a time.

Condition Variable

A synchronization construct that allows a thread to wait until a particular condition becomes true, avoiding continuous checking.

Producer-Consumer Problem

A classic concurrency problem where a producer generates data into a shared buffer and a consumer retrieves it, requiring synchronization to handle buffer full and buffer empty states.

Readers-Writers Problem

A classic concurrency problem involving shared resource access where multiple readers can access concurrently, but writers require exclusive access.

Starvation

A synchronization problem where a thread waits for a very long time because other threads repeatedly receive access to the shared resource first.

Livelock

A state in which threads remain active and continuously change state without making useful progress, continually failing, retrying, and wasting CPU cycles.

Priority Inversion

A scheduling problem where a high-priority task is forced to wait for a low-priority task to release a shared resource.

Barrier

A synchronization mechanism that forces a group of threads to wait until all participating threads reach a specific point.

Atomic Operation

An operation treated as indivisible, preventing other threads from observing it in a partially completed state.

Contention

A scenario that occurs when multiple threads or processes try to access the same limited hardware or software resource at the same time.