Concurrency & Async Programming - Mutexes, Threads & Event Loops Flashcards

Question 1

Reentrant Lock (Recursive Mutex)

Accepted Answer

A mutex that allows the thread currently holding the lock to re-acquire it multiple times without causing a deadlock. It maintains an internal lock count and requires an equal number of release operations to fully unlock.

Question 2

Concurrency vs. Parallelism

Accepted Answer

**Concurrency** is about *structuring* a program by decomposing it into independent execution paths that can overlap in time. **Parallelism** is about *executing* multiple computations simultaneously on separate hardware resources (e.g., multi-core CPUs).

Question 3

Race Condition

Accepted Answer

A flaw in a concurrent system where the output is unexpectedly dependent on the timing or sequence of execution across threads. Occurs when two or more threads access shared memory concurrently, and at least one access is a write without proper synchronization.

Question 4

Mutex (Mutual Exclusion Lock)

Accepted Answer

A locking primitive used to protect a critical section of code. Only one thread can hold the mutex at a time; other threads attempting to acquire it will block until it is released by the owner thread.

Question 5

Counting Semaphore vs. Binary Semaphore

Accepted Answer

A **Counting Semaphore** maintains an integer counter to control access to a finite pool of resources ($N$ total permits). A **Binary Semaphore** has a counter restricted to 0 or 1; unlike a mutex, it lacks ownership tracking, allowing any thread to signal (`post`/`release`) it.

Question 6

Atomic Operations

Accepted Answer

Low-level, hardware-supported memory operations that execute completely without interruption. They guarantee that no other thread can observe a partial state change, enabling lock-free data structures.

Question 7

Compare-And-Swap (CAS)

Accepted Answer

An atomic instruction of the form `CAS(location, expected_val, new_val)`. It checks if `location` contains `expected_val`; if true, it updates it to `new_val` and returns `true`. Otherwise, it leaves memory unchanged and returns `false`.

Question 8

Coffman Conditions for Deadlock

Accepted Answer

Four conditions that must hold simultaneously for a deadlock to occur:
1. **Mutual Exclusion**: Non-shareable resource allocation.
2. **Hold and Wait**: Holding a resource while waiting for another.
3. **No Preemption**: Resources cannot be forcibly taken.
4. **Circular Wait**: A closed chain of threads waiting on each other.

Question 9

Deadlock Avoidance: Lock Ordering

Accepted Answer

A technique to prevent the **Circular Wait** Coffman condition by establishing a strict global hierarchy for lock acquisition. Threads must always acquire locks in the exact same predefined order (e.g., acquire Lock $A$ before Lock $B$).

Question 10

Priority Inversion

Accepted Answer

A scenario where a high-priority thread is indirectly preempted by a lower-priority thread holding a required resource, often because a medium-priority thread preempts the low-priority thread. Solved using **Priority Inheritance**.

Question 11

Thread Pool

Accepted Answer

A software pattern managing a fixed worker set of reusable threads to process an incoming queue of tasks. It eliminates the overhead of creating/destroying OS threads per task and prevents system exhaustion.

Question 12

Green Threads (Virtual Threads)

Accepted Answer

User-space threads managed entirely by a language runtime or VM rather than the OS kernel. They have tiny initial stack footprints (e.g., Go goroutines, Java Virtual Threads) allowing millions of concurrent tasks via $M:N$ multiplexing over OS threads.

Question 13

Event Loop

Accepted Answer

An event-driven programming model where a single main thread continuously runs a loop that checks an event queue and executes registered callbacks. Non-blocking I/O operations are offloaded to OS mechanisms like `epoll` or `kqueue`.

Question 14

Non-Blocking I/O

Accepted Answer

An I/O mode where system calls (e.g., `read()`, `write()`) return immediately instead of waiting for data. If data is not ready, it returns an error/status code (e.g., `EWOULDBLOCK`), allowing the execution context to continue processing other work.

Question 15

Async / Await Syntax & Runtime

Accepted Answer

Syntactic sugar built on top of state machines and Futures/Promises. An `async` function returns a Future; `await` yields control of the thread back to the runtime execution context until the underlying Future resolves, preventing thread blocking.

Question 16

Future / Promise Primitive

Accepted Answer

A read-only placeholder object representing a value that is initially unknown but will be computed and resolved asynchronously in the future (or rejected with an error).

Question 17

Starvation vs. Deadlock

Accepted Answer

**Deadlock** is a permanent, passive stall where threads are blocked indefinitely waiting on resources held by each other. **Starvation** is an ongoing condition where a runnable thread is perpetually denied access to CPU time or resources due to unfair scheduling.

Question 18

Readers-Writer Lock (RW Lock)

Accepted Answer

A concurrent read/write lock permitting concurrent access for multiple **reader** threads, but granting exclusive access to a single **writer** thread when modifications are required.

Question 19

Livelock

Accepted Answer

A concurrency issue where two or more threads continuously change their states in response to actions of other threads without doing any useful work. Unlike deadlock, threads are actively running and consuming CPU resources.

Question 20

False Sharing

Accepted Answer

A performance degradation in multi-threaded programs on modern CPUs. Occurs when threads on different physical cores modify independent variables that reside on the same memory cache line, causing constant, unnecessary cache invalidation bus traffic.

Concurrency & Async Programming - Mutexes, Threads & Event Loops

Cards in this deck

Related Flashcard Sets

HSK 1 - Basic Chinese Vocabulary, Pinyin & Character Recognition

Functional Programming - Immutability, Pure Functions & Higher-Order Functions

Neuroscience - Neuroanatomy & Brain Function

Microsoft Azure Administrator (AZ-104) - Compute, Storage & Networking