OS: Processes, Threads, and Concurrency

A program in execution with its own address space, resources, and at least one thread of control.

A unit of execution within a process that shares the process address space and resources with sibling threads.

Processes are memory-isolated from each other; threads of the same process share memory (requiring synchronization).

Saving the state of one running task and restoring another so the CPU can change which process/thread runs.

When outcome depends on unpredictable timing/interleaving of concurrent operations on shared state.

A code region that accesses shared resources and must not be executed by multiple threads concurrently.

A synchronization primitive that allows only one thread at a time to hold the lock and enter a critical section.

A state where threads wait forever for resources held by each other (circular wait with no progress).

Mutual exclusion; hold-and-wait; no preemption; circular wait.

A synchronization counter supporting wait/signal (P/V) operations — can control access by multiple units of a resource.

User threads are cheaper to switch but a blocking syscall can block the whole process; kernel threads are scheduled by the OS with higher overhead.

CPU-bound tasks mostly compute; I/O-bound tasks often wait on I/O — schedulers mix them for responsiveness and utilization.