multithreading

Multithreading is a programming and execution model that allows a single process to manage multiple threads of control concurrently. Each thread represents an independent path of execution within the same address space, enabling tasks to run in overlapping time periods. Multithreading is used to improve responsiveness, resource utilization, and throughput, particularly on multi-core processors where threads may run in parallel.

There are several threading models described in operating system theory. Kernel-level threads are scheduled by the operating system, while user-level threads are scheduled by a thread library within the process. In some models, many user threads map to a smaller number of kernel threads, while in others there is a direct one-to-one mapping. Modern systems typically provide kernel-supported threads, with libraries and language runtimes that build higher-level abstractions on top of them.

Because threads share memory, proper synchronization is needed to avoid data races. Synchronization primitives such as mutexes, locks, condition variables, and atomic operations coordinate access to shared data. Memory visibility and ordering rules are essential to ensure changes by one thread become visible to others. Lock-free and wait-free algorithms exist but are complex and error-prone.

Thread scheduling is subject to operating system policies and can incur context-switch overhead. Thread pools and task-based parallelism reduce overhead by reusing a fixed number of threads to execute tasks. Performance depends on contention, false sharing, and I/O patterns; maximizing parallelism requires balancing fine-grained versus coarse-grained tasks.

Common problems include deadlock, livelock, priority inversion, and starvation. Designing thread-safe interfaces, minimizing shared state, and using immutable data where possible help. Debugging concurrent code is challenging due to nondeterminism.

Different programming environments provide various abstractions for multithreading, including POSIX threads, Windows threads, Java threads, and language-specific models such as Go's goroutines or Rust's thread API. Understanding the trade-offs between concurrency and parallelism is central to effective multithreaded design.