Concurrency

What Is Concurrency?

Concurrency is the ability of a program to manage multiple tasks simultaneously, even if they don’t all execute at the exact same time.

It’s not necessarily doing many things at once, but dealing with many things at once.

Concurrency is a key to building responsive, scalable, and efficient applications in today’s multi-core, multi-threaded computing environment.

1. Concurrency vs. Parallelism

Concept	Description
Concurrency	Managing multiple tasks at the same time (may share a single CPU core)
Parallelism	Actually running tasks at the same time (requires multiple cores)

Concurrency is about structure, while parallelism is about execution.

You can have concurrency without parallelism, but rarely parallelism without concurrency.

2. Why Is Concurrency Important?

Responsiveness (UI stays responsive while tasks run in background)
Resource utilization (maximizes CPU use)
Scalability (handles many users or I/O operations efficiently)
Decoupled design (different concerns can operate independently)

Examples:

Web servers handling thousands of requests
Mobile apps performing background downloads
Real-time gaming or audio/video streaming

3. How Concurrency Works

Concurrency is implemented via:

Threads
Processes
Coroutines
Event loops
Asynchronous I/O

Each has tradeoffs in complexity, performance, and safety.

4. Threads and Threading Models

Threads

Share memory space
Light-weight compared to processes
Communicate via shared variables

Threading Models

Model	Description
User-level threads	Managed by application (e.g., green threads)
Kernel threads	Managed by OS scheduler
Hybrid	Mix of both (e.g., Java, Linux pthreads)

5. Concurrency in Programming Languages

C/C++

pthread (POSIX threads)
OpenMP for parallelism

pthread_create(&thread, NULL, function, NULL);

Java

Thread, Runnable, ExecutorService

new Thread(() -> {
    System.out.println("Running in thread");
}).start();

Python

threading, asyncio, multiprocessing

import threading

def task():
    print("Hello from thread")

t = threading.Thread(target=task)
t.start()

Go

Goroutines and channels (built-in lightweight concurrency)

go doSomething()

Rust

Ownership model + std::thread, tokio async runtime

std::thread::spawn(|| println!("Hello from thread"));

6. Asynchronous Programming

Asynchronous (async) programming is a form of concurrency that:

Doesn’t block threads
Uses await/async keywords (Python, JS, Rust, etc.)
Enables scalability without using many OS threads

Example (Python):

async def fetch_data():
    await some_network_call()

7. Concurrency Patterns

Pattern	Description
Producer-Consumer	One thread produces, another consumes
Reader-Writer	Multiple readers, single writer
Worker Pool	Distribute work across a fixed number of threads
Event Loop	Single-threaded dispatcher (e.g., JavaScript, Node.js)
Reactive Programming	Event-driven stream handling (e.g., RxJS, Reactor)

8. Synchronization Techniques

Concurrency introduces race conditions, so we use synchronization primitives:

Primitive	Use
Mutex (Lock)	Ensures only one thread accesses a resource at a time
Semaphore	Controls access to limited resources
Condition Variables	Wait and notify for complex coordination
Atomic Variables	Perform operations safely without locks
Futures/Promises	Handle results of async operations

Example (Python):

from threading import Lock

lock = Lock()
with lock:
    # safe access

9. Common Concurrency Problems

Problem	Description
Race Condition	Two threads access and modify shared data unpredictably
Deadlock	Two threads wait on each other forever
Livelock	Threads keep changing state but make no progress
Starvation	A thread never gets CPU time or access
Priority Inversion	Low-priority thread blocks a high-priority one

10. Tools and Debugging

Thread Sanitizers (TSAN)
Valgrind
GDB/Lldb with multithreading support
Java VisualVM
Python’s concurrent.futures and asyncio debugger
Go race detector

11. Concurrency in Modern OS and Hardware

Modern CPUs support hardware threads (Hyper-threading)
OS schedulers manage thread priorities, CPU affinity, and context switching
Real-time OS (RTOS) require deterministic concurrency handling
Concurrent GC (Garbage Collection) in JVM, .NET

12. When to Avoid Concurrency

Small programs with no I/O
CPU-bound tasks without multiple cores
Tight real-time constraints (use state machines instead)
If logic is hard to synchronize or debug

Concurrency can complicate code. Only use it when it adds real value.

Summary

Topic	Key Point
Definition	Managing multiple tasks at once (not necessarily parallel)
Main Methods	Threads, async/await, processes, coroutines
Languages	Supported in Java, C++, Python, Go, Rust
Benefits	Responsiveness, scalability, performance
Risks	Race conditions, deadlocks, hard debugging
Synchronization	Locks, semaphores, atomic ops, channels
Tools	Debuggers, profilers, static analyzers