Concurrency & Parallelism - Threads, Locks & Race Conditions Flashcards

Question 1

Concurrency vs. Parallelism

Accepted Answer

• **Concurrency**: Managing multiple tasks at once by interleaving execution on a single core or across multiple cores (about *structure*).
• **Parallelism**: Executing multiple tasks simultaneously on physically separate processor cores or hardware (about *execution*).

Question 2

Process vs. Thread

Accepted Answer

• **Process**: An isolated execution environment with its own private virtual memory space (heap, stack, code).
• **Thread**: A lightweight unit of execution within a process that shares memory (heap, code, global data) with sibling threads, keeping only its own stack and instruction pointer.

Question 3

Critical Section

Accepted Answer

A segment of code that accesses shared resources (such as memory, global variables, or files) that must not be concurrently accessed by more than one thread or process to prevent data corruption.

Question 4

Race Condition

Accepted Answer

A defect occurring when the output or state of a system depends on the uncontrolled relative timing or sequence of thread execution. Occurs when two or more threads access shared state concurrently, and at least one access is a write.

Question 5

Race Condition Code Example & Solution

Accepted Answer

A non-atomic increment `counter++` involves three instructions: read, modify, write back. Interleaving causes lost updates.

**Vulnerable:**
```python
counter += 1  # Not thread-safe
```
**Thread-Safe Fix:**
```python
with lock:
    counter += 1
```

Question 6

Mutex (Mutual Exclusion Lock)

Accepted Answer

A synchronization primitive used to enforce single-thread access to a critical section. A mutex has an ownership concept: only the specific thread that acquired (locked) the mutex can release (unlock) it.

Question 7

Semaphore

Accepted Answer

A signaling mechanism that maintains a non-negative integer counter controlling access to a pool of shared resources.
• `acquire()` / `wait()` / `P()`: Decrements the count. Blocks if count is $0$.
• `release()` / `signal()` / `V()`: Increments the count, unblocking a waiting thread.

Question 8

Binary Semaphore vs. Mutex

Accepted Answer

• **Binary Semaphore**: Counter restricted to values $0$ or $1$. Lacks ownership semantics; thread $A$ can acquire it while thread $B$ releases it (useful for signaling).
• **Mutex**: Possesses strict ownership; only the thread that locks it can unlock it.

Question 9

Counting Semaphore

Accepted Answer

A semaphore initialized with a count $N > 1$, allowing up to $N$ threads to concurrently access a limited pool of identical resources (e.g., database connection pools).

Question 10

Deadlock

Accepted Answer

A state where two or more threads are permanently blocked, each waiting for a resource held by another thread in the set, preventing any of them from making progress.

Question 11

The 4 Coffman Conditions for Deadlock

Accepted Answer

Deadlock can occur if and only if all four conditions hold simultaneously:
1. **Mutual Exclusion**: Resources cannot be shared.
2. **Hold and Wait**: Threads hold resources while waiting for others.
3. **No Preemption**: Resources cannot be forcibly revoked.
4. **Circular Wait**: A closed loop of threads exists, each waiting for a resource held by the next.

Question 12

Deadlock Prevention Strategy: Resource Hierarchy

Accepted Answer

To eliminate the **Circular Wait** condition, establish a global strict total order for acquiring locks. Threads must always acquire locks in ascending numerical/hierarchical order (e.g., acquire `Lock A` before `Lock B`).

Question 13

Livelock

Accepted Answer

A scenario where two or more threads continuously change their states in response to each other without making any useful progress. Unlike deadlock, the threads remain active and consume CPU resources.

Question 14

Resource Starvation

Accepted Answer

A problem where a runnable thread is perpetually denied necessary resources (e.g., CPU scheduling, locks) due to greedy threads or biased scheduling algorithms.

Question 15

Spinlock

Accepted Answer

A lock where a thread repeatedly checks if the lock is available in a tight loop ("busy-waiting"). Efficient for short lock durations as it avoids kernel context-switching overhead, but wastes CPU if held long.

Question 16

Condition Variable

Accepted Answer

A synchronization primitive that enables threads to suspend execution until a specific logical condition becomes true. Always used inside a mutex loop to protect condition evaluation and avoid missed signals.

Question 17

Atomic Operation & Compare-And-Swap (CAS)

Accepted Answer

An operation that completes as a single, indivisible hardware instruction.
• **Compare-And-Swap (CAS)**: Atomically compares a memory location $V$ with expected value $E$, and updates it to new value $N$ if $V == E$. Forms the foundation of lock-free data structures.

Question 18

Read-Write Lock (RW Lock)

Accepted Answer

A lock optimized for read-heavy resources:
• Multiple threads can acquire the lock concurrently in **shared (read)** mode.
• Only one thread can acquire the lock in **exclusive (write)** mode, blocking all readers and other writers.

Question 19

Reentrant Lock (Recursive Mutex)

Accepted Answer

A mutex that allows the thread currently holding the lock to acquire it again without causing self-deadlock. It maintains a hold count that decrements on each release, unlocking only when count hits zero.

Question 20

Producer-Consumer Problem (Bounded Buffer)

Accepted Answer

A classic synchronization problem with shared fixed-size buffers.
• Solved using a **Mutex** for safe buffer modification.
• Two **Semaphores** (or Condition Variables): `empty_slots` (initialized to buffer capacity $N$) and `full_slots` (initialized to $0$).

Concurrency & Parallelism - Threads, Locks & Race Conditions

Cards in this deck

Related Flashcard Sets

JLPT N2 - Upper-Intermediate Japanese Kanji, Grammar & Expressions

CompTIA Network+ (N10-008) - Networking Fundamentals & Subnetting

HSK 4 - Intermediate Chinese Vocabulary & Grammar

CompTIA Network+ (N10-008) - Networking Fundamentals & Protocols