4. Multithreading and Concurrency

Processes

A process is an independent program with its own memory space. Multiple processes can run at the same time, and the operating system manages them. Processes are isolated, which improves safety but makes communication more complex.

Threads

Threads are lighter‑weight units of execution within a process. Multiple threads in the same process share memory and resources. This sharing makes threads efficient for parallel tasks but introduces the risk of race conditions.

Use separate processes when isolation and reliability are critical (e.g., microservices, sandboxing). Use threads when you want to parallelize tasks within the same application and share data efficiently.

Because threads share memory, two threads can try to modify the same data at the same time, causing race conditions. The result can be inconsistent or unpredictable state.

Synchronization primitives like mutexes, semaphores, and condition variables coordinate access to shared resources. They ensure that only one thread accesses critical sections at a time or that threads wait for certain conditions.

Proper synchronization avoids data corruption but can introduce contention and deadlocks if misused. Designing concurrent code often involves balancing safety and performance.

Parallel programming focuses on doing multiple tasks at the same time to speed up computation, typically on multi‑core CPUs. Concurrency is about managing multiple tasks that may interleave, even on a single core. Parallelism is a subset of concurrency.

Data parallelism means applying the same operation to many elements (e.g., processing an array in chunks). Task parallelism means running different tasks simultaneously. Frameworks often provide abstractions for both styles.

Parallel programming is useful for CPU‑bound tasks like numerical simulations, data processing, and heavy computations. Effective parallelization requires splitting work, minimizing synchronization, and avoiding excessive overhead.

Asynchronous programming is about handling tasks that involve waiting (like I/O) without blocking the main thread. Instead of pausing everything, you register callbacks or use async/await constructs so the program can do other work while waiting.

Many languages use event loops, futures, or promises to model ongoing operations. The idea is to schedule tasks and resume them when results become available, which improves throughput for I/O heavy workloads.

Async is ideal for servers handling many connections, clients calling remote APIs, or apps that must stay responsive while doing background work. It is less about raw CPU speed and more about efficient use of time and resources.