Multithreading
Multithreading is a concurrency technique in which multiple threads of execution operate within a program or process, with their work interleaved or running in parallel.
Rust Servers, Services, and Apps
Multithreading is a technique for executing multiple threads of control within a process, potentially in parallel or through interleaving.
- How it is used
- Uses multithreading to handle concurrent web-service work and to contrast OS threads with async I/O.
- How deep it goes
- Works through spawning and joining threads for simulated file reads, then identifies Actix worker defaults; does not detail thread scheduling internals.
- Examples
- Compares sequential and spawned four-second and two-second file reads, and uses Actix worker threads as a server example.
- What you can do after
- Apply it via Rust `thread::spawn` and `join`, and evaluate/understand how Actix workers handle parallel server work.
Read how Rust Servers, Services, and Apps explains multithreading →
Python Concurrency with asyncio
Multithreading is a concurrency technique in which multiple threads execute within a process and share its memory.
- How it is used
- Deploys threads to overlap blocking I/O, integrate synchronous libraries with asyncio, and support responsive applications.
- How deep it goes
- Explains thread creation, joining, GIL constraints, shared-memory races, locks, pools, deadlocks, and selected GIL-releasing workloads.
- Examples
- Demonstrates hello-world threads, concurrent requests with progress tracking, Fibonacci timing, and NumPy row means.
- What you can do after
- Apply it via threading, ThreadPoolExecutor, asyncio, and Lock to run blocking work concurrently and synchronize shared state.
Read how Python Concurrency with asyncio explains multithreading →
C# Concurrency: Asynchronous and multithreaded programming
The execution of multiple threads within a program, either concurrently through interleaving or simultaneously on multiple processor cores.
- How it is used
- Uses parallel or background execution to improve completion time, responsiveness, server capacity, or perceived performance.
- How deep it goes
- Explains interleaving, cores, context switching, thread pools, continuations, performance costs, and classic synchronization failures.
- Examples
- Demonstrates pizza and web-server workflows, multicore scheduling, ten-file processing, parallel calculations, and responsive WinForms updates.
- What you can do after
- Apply multithreading with Task.Run, compare it with asynchronous I/O, preserve UI responsiveness, and identify common concurrency hazards.
Read how C# Concurrency: Asynchronous and multithreaded programming explains multithreading →
C++ Concurrency in Action, Second Edition
A programming technique in which a program uses multiple threads of execution within a process.
- How it is used
- Uses multiple threads within a process to separate responsibilities or perform concurrent work.
- How deep it goes
- Works through thread creation and joining, then identifies synchronization and work-division decisions without detailing their implementations.
- Examples
- Uses a C++ greeting launched with std::thread and joined from main(), plus separate threads for media playback and user input.
- What you can do after
- Build it from scratch as a simple C++ program using std::thread and join(), and evaluate when additional threads are worthwhile.
Read how C++ Concurrency in Action, Second Edition explains multithreading →
Fast Python: High performance techniques for large datasets
- How it is used
- Tests whether concurrent MapReduce jobs can exploit multicore hardware, then informs worker configuration for data-processing workloads.
- How deep it goes
- Explains the GIL’s execution limit and thread-switching cost, but does not develop a low-level thread implementation.
- Examples
- Uses a concurrent.futures MapReduce executor and configurable dask.distributed workers to contrast threaded jobs with process-based deployment.
- What you can do after
- Operate/configure it in dask.distributed by selecting worker processes and threads for the workload without assuming threads accelerate Python code.
Read how Fast Python: High performance techniques for large datasets explains multithreading →
Software Design for Python Programmers
A multithreaded program is a program whose execution can involve multiple concurrent threads of control.
- How it is used
- Uses simultaneous operations such as producer–consumer queues and shared-resource access to motivate synchronization design.
- How deep it goes
- Explains concurrency, parallelism, critical regions, mutex locking, and practical risks, but only briefly introduces broader Python facilities.
- Examples
- Demonstrates unsynchronized and mutex-protected Python printing with three threads, shared output, locking, joining, and varied scheduling.
- What you can do after
- Apply it via Python's threading module to create, start, join, and synchronize threads around shared resources.
Read how Software Design for Python Programmers explains multithreading →
Server-Side WebAssembly
Multithreading is the concurrent execution of multiple threads within a process or application.
- How it is used
- Frames multithreading support as a key constraint when assessing Wasm for concurrent server workloads.
- How deep it goes
- Explains the limitation through a concurrent-client latency benchmark and CPU-core utilization, then defers Kubernetes deployment details.
- Examples
- Uses a SQL-backed service stressed by 50 concurrent clients and compares Wasm with Docker CPU utilization and latency.
- What you can do after
- Evaluate/understand when Wasm's threading limitation harms PaaS throughput and when per-request instances or Kubernetes scaling can reduce the effect.
Learn Concurrent Programming with Go
Multithreading is a programming approach in which multiple threads execute concurrently within a single process or application.
- How it is used
- Uses multiple threads to share application memory and handle independent work concurrently.
- How deep it goes
- Explains thread structure, resource costs, shared memory, and risks, but does not detail synchronization mechanisms.
- Examples
- Illustrates a sports-score service with a stream-reader thread, client-handler threads, shared scores, and a dynamic thread pool.
- What you can do after
- Evaluate when lightweight shared-memory execution suits concurrent server work and recognize its isolation and coordination costs.
Read how Learn Concurrent Programming with Go explains multithreading →
Functional Design and Architecture: Examples in Haskell
Multithreading is the concurrent execution of multiple threads within a process.
- How it is used
- Frames multithreading as an architectural concern for readable, maintainable concurrent applications and general-purpose web or CLI frameworks.
- How deep it goes
- Explains major failure modes and state primitives, then stops short of comprehensive multithreading internals while comparing STM with bare threads.
- Examples
- Uses race conditions, deadlocks, livelocks, starvation, leakage, overflow, and exception-handling failures as concrete problem cases.
- What you can do after
- Diagnose concurrency risks, choose among IORefs, MVars, and STM TVars, and organize threads with safer resource handling.
Read how Functional Design and Architecture: Examples in Haskell explains multithreading →
Object-Oriented Software Design in C++
Multithreading is the concurrent execution of multiple independently schedulable threads within a program.
- How it is used
- Uses multithreading to exploit multicore execution and support applications requiring simultaneous operations.
- How deep it goes
- Introduces threads, concurrency, parallelism, mutexes, and condition variables, but stops short of comprehensive implementation guidance.
- Examples
- Uses a printing example, a dinner-party analogy, and a singleton initialization race to illustrate synchronization problems.
- What you can do after
- Apply mutexes and condition variables to protect shared resources and coordinate multiple threads.
Read how Object-Oriented Software Design in C++ explains multithreading →
Refactoring to Rust
Multithreaded computation is the execution of computational work across multiple threads within a program.
- How it is used
- Deploys parallel workers for calculations and tasks blocked by resource constraints or external libraries.
- How deep it goes
- Explains operating-system threads, worker throughput, completion ordering, and Python’s limits, but defers the runtime mechanism requiring Rust.
- Examples
- Uses eight Mandelbrot image calculations submitted to a four-worker ThreadPoolExecutor.
- What you can do after
- Apply multithreading via Python’s ThreadPoolExecutor and coordinate submitted work with asyncio.gather.
Related concepts
- threaduses · A thread is an independently schedulable sequence or context of execution within a program or process.
- blockingaddresses · Execution behavior in which an operation prevents its calling execution flow from progressing until required work, an event, a resource, or a condition is ready or complete.
- global interpreter lockcontrasts with · The global interpreter lock is a mutual-exclusion mechanism in CPython that permits only one thread at a time to execute Python bytecode within a process.
- lockinguses · Locking is a synchronization technique that restricts concurrent access to shared resources or protected operations.
- parallelismkind of · Parallelism is the concurrent execution of multiple computational operations, often across multiple processing resources.
- debuggercontrasts with · A debugger is a software tool for controlling program execution and inspecting runtime state to investigate behavior and diagnose defects.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.