Concurrency
Concurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously.
Go in Action, Second Edition
Concurrent programming is the design of software whose multiple execution activities can make progress during overlapping periods of time.
- How it is used
- Uses concurrency to keep applications responsive and make progress on independent network, I/O, or background tasks.
- How deep it goes
- Works through goroutines, channel-based processing, and operational safeguards, but does not descend into runtime scheduler internals.
- Examples
- Builds an RSS reader that fetches news feeds concurrently, passes articles to storage, and exposes saved articles over HTTP.
- What you can do after
- Apply it via `gofeed` to fetch multiple RSS feeds with goroutines and route articles through channels for storage.
Read how Go in Action, Second Edition explains concurrency →
Python Concurrency with asyncio
A way of structuring work so that multiple tasks make progress during overlapping periods, including by switching between them while each is incomplete.
- How it is used
- Improves responsiveness and throughput by overlapping I/O waits in web, database, socket, and microservice applications.
- How deep it goes
- Explains task switching, parallelism, multitasking, GIL effects, sockets, event loops, coroutines, and task scheduling.
- Examples
- Uses cake baking, web-page downloads, status-code requests, delayed coroutines, echo servers, database queries, and microservice calls.
- What you can do after
- Build it from scratch by choosing threads, processes, or asyncio tasks for I/O-bound and CPU-bound workloads.
Read how Python Concurrency with asyncio explains concurrency →
Grokking Concurrency
Concurrent execution is execution in which multiple tasks make progress during overlapping periods, whether or not they run simultaneously on separate resources.
- How it is used
- Uses concurrency to organize overlapping work for performance, scalable systems, decoupling, and responsive network applications.
- How deep it goes
- Defines overlapping execution, distinguishes parallelism, traces application/runtime/hardware layers, and introduces processes, threads, coordination, and design practice.
- Examples
- Illustrates overlapping work with a cook, an arcade machine, a blocked server, and pooled password-cracking workers.
- What you can do after
- Build concurrent applications by splitting work into independent tasks, selecting processes or threads, and recognizing coordination risks.
Elixir in Action, Third Edition
Concurrency is the capability for multiple computational activities to make progress during overlapping periods of execution.
- How it is used
- Supports responsive, scalable, fault-tolerant server-side systems handling requests, shared state, and background work.
- How deep it goes
- Explains BEAM processes, scheduling, message passing, isolation, spawning, and request architecture, while deferring detailed recovery mechanisms.
- Examples
- Uses concurrent query execution, isolated to-do servers, and per-request HTTP processes to demonstrate implementation and production behavior.
- What you can do after
- Build it from scratch by spawning lightweight processes, passing data through closures, and assigning independent requests to separate processes.
Read how Elixir in Action, Third Edition explains concurrency →
Learn Concurrent Programming with Go
A programming technique for writing software in which multiple tasks or processes can make progress during overlapping periods of time.
- How it is used
- Structures overlapping tasks to improve responsiveness, use I/O waits, scale work, and model simultaneous business interactions.
- How deep it goes
- Defines task structuring and contrasts parallel execution, then demonstrates goroutines, races, shared memory, and channel-based stopping.
- Examples
- Uses payroll, online orders, shipment consolidation, a word processor, web-page letter counting, and brute-force password discovery.
- What you can do after
- Evaluate/understand when overlapping tasks can improve responsiveness or throughput and where coordination errors can arise.
Read how Learn Concurrent Programming with Go explains concurrency →
C++ Concurrency in Action, Second Edition
Concurrency is the structuring and execution of multiple tasks whose progress overlaps, whether or not they run at the exact same time.
- How it is used
- Organizes overlapping application work to separate responsibilities, preserve responsiveness, or exploit available processing capacity.
- How deep it goes
- Defines concurrency, compares execution and organization models, and walks through a GUI-worker outline without detailing memory-model rules.
- Examples
- Uses single-core and dual-core execution, a DVD player’s playback and input, and a GUI event loop with a worker thread.
- What you can do after
- Apply it via C++ Standard Library threads to separate lengthy work from GUI event handling, while weighing threading costs.
Read how C++ Concurrency in Action, Second Edition explains concurrency →
Latency
Concurrency is the structuring of multiple computations so that their execution can overlap in time, including through interleaving on one execution resource.
- How it is used
- Uses overlapping tasks to keep latency-sensitive applications responsive while operations wait or other work proceeds.
- How deep it goes
- Defines interleaving versus parallelism, relates in-flight work to latency through Little’s law, and measures a concurrent implementation.
- Examples
- Compares single-core thread scheduling, a 1,000-request-per-second system, and sequential versus Tokio join_all execution of ten delayed tasks.
- What you can do after
- Apply it via Tokio join_all to overlap waiting tasks, then diagnose capacity using task counts, pool utilization, and queue depths.
Rust Servers, Services, and Apps
Concurrent programming is the design of programs whose multiple operations can make progress during overlapping periods of time.
- How it is used
- Supports safe, responsive handling of concurrent HTTP requests within an individual web service.
- How deep it goes
- Defines concurrency against parallelism, compares scheduling models, and works through sequential, threaded, and Tokio-based examples.
- Examples
- Compares two delayed file reads run sequentially, in operating-system threads, and in Tokio tasks.
- What you can do after
- Practice/perform it by spawning and joining independent Rust threads, then trying Tokio tasks with explicit awaits.
Read how Rust Servers, Services, and Apps explains concurrency →
100 Go Mistakes and How to Avoid Them
Concurrent execution is the overlapping progress of two or more threads or computations during the same time period.
- How it is used
- Structures overlapping work in Go while challenging the assumption that adding goroutines automatically improves performance.
- How deep it goes
- Defines concurrency against parallelism, traces Go scheduling, and works through benchmarked merge-sort implementations without fully elaborating sync.WaitGroup.
- Examples
- Contrasts coffee-shop staffing designs and benchmarks sequential, unrestricted parallel, and cutoff-based merge sort.
- What you can do after
- Evaluate/understand it by benchmarking sequential and concurrent designs, then selecting coordination or synchronization according to goroutine interactions.
Read how 100 Go Mistakes and How to Avoid Them explains concurrency →
Refactoring to Rust
Concurrency is the structuring of multiple executions so that they make progress during overlapping periods without necessarily running simultaneously.
- How it is used
- Structures independent application work to address bottlenecks and improve throughput.
- How deep it goes
- Defines concurrency, contrasts parallelism, and demonstrates thread-pool and GIL-release implementation steps.
- Examples
- Uses email fetching, a can crusher analogy, and concurrent Mandelbrot image generation.
- What you can do after
- Apply concurrency with asyncio, ThreadPoolExecutor, Rust, and PyO3 to improve a measured compute bottleneck.
Rust in Action: Systems programming concepts and techniques
Concurrency is the execution of multiple computational activities during overlapping time periods, potentially on the same or different processors.
- How it is used
- Frames how Rust carries out multiple tasks while addressing the risks of independent threads.
- How deep it goes
- Explains scheduling and isolation trade-offs and introduces concurrency tools, but stops short of implementing concurrency crates.
- Examples
- Uses a rejected thread-spawning race example and measured sleep-versus-spin-loop workloads on a six-core CPU.
- What you can do after
- Apply it via Rust’s standard library, crossbeam, and rayon while choosing among available concurrency tools.
Read how Rust in Action: Systems programming concepts and techniques explains concurrency →
Go by Example
Concurrency is the ability to structure a program so that multiple execution activities can make progress during overlapping periods.
- How it is used
- Structures HTTP request processing into concurrent pipeline stages while preserving a synchronous package API.
- How deep it goes
- Explains goroutines, channels, scheduling, pipeline design, API hiding, and scaling limits, while deferring scheduler internals.
- Examples
- Demonstrates concurrent web crawling and a HIT client sending 100 requests with one or ten workers and optional RPS throttling.
- What you can do after
- Build concurrent Go processing with goroutines, channels, and pipeline stages while keeping package APIs synchronous.
Java Persistence with Spring Data and Hibernate epub
Concurrency is the execution or management of multiple activities whose operations may overlap in time.
- How it is used
- Frames the problem of overlapping database transactions that access or change shared data.
- How deep it goes
- Explains four anomalies through transaction interleavings and compares isolation levels, without detailing lock algorithms.
- Examples
- Uses competing price updates, uncommitted changes, changing bids, and repeated queries to illustrate anomalies.
- What you can do after
- Evaluate/understand overlapping transactions by identifying anomalies and comparing the protection offered by isolation levels.
Read how Java Persistence with Spring Data and Hibernate epub explains concurrency →
Functional Design and Architecture: Examples in Haskell
A programming technique for structuring multiple computations whose execution can overlap in time.
- How it is used
- Structures reactive simulators and multithreaded application frameworks around independently reacting components and controlled shared state.
- How deep it goes
- Explains major failure modes and compares STM with bare threads, while stopping short of comprehensive multithreading pitfalls and implementation internals.
- Examples
- Uses a reactive simulator, actor-like components, concurrent web servers, command-line applications, and STM-backed framework state.
- What you can do after
- Build it from scratch by selecting state mechanisms, organizing threads safely, and incorporating STM into maintainable application architecture.
Read how Functional Design and Architecture: Examples in Haskell explains concurrency →
Code Like a Pro in Rust
Concurrency is the ability for multiple computations to make progress during overlapping periods, whether or not they execute simultaneously.
- How it is used
- Uses concurrency to overlap waiting tasks, especially I/O, rather than process every operation sequentially.
- How deep it goes
- Demonstrates Tokio task composition and blocking versus nonblocking sleep, while leaving individual task-to-thread scheduling to the runtime.
- Examples
- Compares sequential awaits, joined tasks, and spawned tasks using blocking and nonblocking one-second sleeps and their printed order.
- What you can do after
- Apply it via Tokio joins, selection, and task spawning while choosing async only when the workload needs concurrency.
PostgreSQL Mistakes and How to Avoid Them
Concurrency is the condition in which multiple operations or users access or modify a system at overlapping times.
- How it is used
- Uses client concurrency to explain PostgreSQL performance limits when configuring connections and evaluating workload capacity.
- How deep it goes
- Explains concurrency through connection overhead, latency/TPS measurements, LWLock contention, and autovacuum consequences without exhaustively detailing internals.
- Examples
- Uses pgbench runs from 2,000 to 16 clients, reporting TPS and average latency across the tested counts.
- What you can do after
- Operate/configure PostgreSQL by selecting workload-tested connection limits and avoiding idle or long-running transactions.
Read how PostgreSQL Mistakes and How to Avoid Them explains concurrency →
Learn Go with Pocket-Sized Projects
Concurrency is the structuring and execution of multiple computational activities that can make progress during overlapping periods.
- How it is used
- Structures independent work in Go programs, especially networked servers and shared components such as caches.
- How deep it goes
- Distinguishes concurrency from parallelism, introduces goroutines, and selects strategies by workload limits and benchmarking.
- Examples
- Uses cooking tasks, file line counting, video encoding, REST requests, and a concurrency-safe key-value cache.
- What you can do after
- Evaluate workloads, structure independent tasks with goroutines, and design safer concurrent components.
Read how Learn Go with Pocket-Sized Projects explains concurrency →
Akka in Action, Second Edition
The property of structuring processes so that they can function simultaneously or overlap in time without requiring simultaneous execution.
- How it is used
- Frames scalable cloud applications as systems that must handle overlapping work and changing resource demand.
- How deep it goes
- Defines concurrency against parallelism and time slicing, then relates it to threads, servers, and actor messaging.
- Examples
- Contrasts a growing business chat application using threads, database polling, and RPC with an actor-based design.
- What you can do after
- Evaluate/understand why message-based actors can decouple concurrent processes from thread and server counts.
Read how Akka in Action, Second Edition explains concurrency →
Go in Practice, Second Edition
Concurrent execution is the progression of multiple computations during overlapping time intervals.
- How it is used
- Deploys concurrency for independent processing, intergoroutine communication, synchronization, and time-bounded background work.
- How deep it goes
- Explains goroutines, channels, blocking, direction, and lifetime with runnable examples, while deferring implementation theory and CSP underpinnings.
- Examples
- Uses concurrent printing, integer channel transfer, and a thirty-second terminal echo task.
- What you can do after
- Apply it via Go goroutines, channels, sleeps, and context deadlines to coordinate concurrent tasks and communication.
Read how Go in Practice, Second Edition explains concurrency →
Fast Python: High performance techniques for large datasets
- How it is used
- Supports overlapping I/O waits and handling multiple requests, separately from using parallel execution to consume CPU resources.
- How deep it goes
- Defines overlap versus simultaneous execution and notes Python's GIL and asynchronous facilities, without developing implementation steps.
- Examples
- Illustrates overlapping tasks with I/O waits and simultaneous client queries to a single-computer MapReduce service.
- What you can do after
- Apply asynchronous programming to serve many concurrent requests without requiring parallel solutions.
Read how Fast Python: High performance techniques for large datasets explains concurrency →
Architecting an Apache Iceberg Lakehouse
Concurrency is the handling of multiple operations or requests that execute or overlap during the same period.
- How it is used
- Frames concurrency as a storage-selection criterion for simultaneous engines, users, pipelines, and peak dashboard workloads.
- How deep it goes
- Explains contention, throttling, access patterns, and workload tradeoffs, but stops short of implementation configuration.
- Examples
- Uses interactive dashboards, overnight batch ETL, and catalog evaluation as concrete workload contexts.
- What you can do after
- Evaluate storage and catalog options against concurrent load, latency, throughput, and contention.
Read how Architecting an Apache Iceberg Lakehouse explains concurrency →
Kotlin in Action, 2E
Concurrency is the execution of multiple pieces of computation during overlapping periods of time, whether or not they execute physically at the same instant.
- How it is used
- Keeps interfaces responsive, coordinates concurrent requests, and sustains server throughput during long-running operations.
- How deep it goes
- Defines concurrency versus parallelism and sketches coroutine mechanics, while deferring detailed suspension, async, and structured-concurrency treatment.
- Examples
- Uses responsive interfaces, concurrent network calls, sequential user loading, and concurrent image loading with async and await.
- What you can do after
- Apply it via Kotlin coroutines to suspend network work, run independent operations concurrently, and coordinate results without blocking threads.
Think Distributed Systems
Concurrent execution is the overlapping execution of operations from multiple transactions without requiring one transaction to finish before another begins.
- How it is used
- Frames overlapping operations and transactions as a problem of causal order and database correctness.
- How deep it goes
- Defines causal ordering and serializability, then illustrates failure and temporary inconsistency without detailing implementation mechanisms.
- Examples
- Uses message events, a funds transfer, partial writes, and equivalent serial transaction orders.
- What you can do after
- Evaluate concurrent executions by checking causal order, consistency preservation, and equivalence to a serial transaction order.
Related concepts
- parallelismcontrasts with · Parallelism is the concurrent execution of multiple computational operations, often across multiple processing resources.
- sequential processingcontrasts with · The execution of operations one after another in a defined order, without overlapping their progress.
- actorincludes · An actor is an independent entity or participant that performs actions, maintains or pursues state or goals, and interacts with other entities or systems.
- asynchronous programmingused by · Asynchronous programming is an execution approach in which operations can progress independently without requiring the initiating flow to wait for their completion or an immediate response.
- workflowuses · A workflow is an organized sequence of coordinated activities, tasks, or decisions through which work progresses toward an outcome.
- goroutineuses · A goroutine is a lightweight function execution unit managed by the Go runtime that runs concurrently with other program activity.
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.