Threads

Threads are the basic units of CPU utilization within a process. A thread represents an independent flow of control with its own program counter, stack, and local variables, while sharing the process’s address space and resources such as open files and memory. Because multiple threads in a process can run concurrently, a single process can perform several tasks at once.

Threads can be implemented in several ways. Kernel threads are scheduled directly by the operating system. User-level threads are managed by a library in user space and may be scheduled without kernel involvement, though blocking operations can affect all threads unless the system provides support. In many systems, a hybrid model combines user-level threading with a pool of kernel threads to balance lightweight management with proper blocking and scheduling.

Scheduling and context switching are core aspects of threading. The OS or runtime schedules runnable threads, often preemptively, and context switches require saving and restoring a thread’s register state, stack, and other state. This overhead is typically small compared with full process switches but can affect performance in highly parallel workloads.

Threads within a process share memory and resources, which simplifies communication but introduces concurrency risks. Synchronization primitives such as mutexes, condition variables, and barriers help coordinate access to shared data. Correct use of these primitives is essential to avoid data races, deadlocks, livelocks, and starvation. Memory visibility and the language’s memory model also influence correctness.

Benefits of multithreading include improved responsiveness and better resource utilization, especially on multicore systems. Drawbacks include increased programming complexity and potential for synchronization issues. Common patterns include thread pools and structured concurrency to manage lifetimes and resource use.

Common examples include POSIX threads, Java threads, and .NET threads, with language and framework libraries providing higher-level abstractions for composing concurrent tasks.