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 improve responsiveness and coordinate independent or I/O-bound work.
- How deep it goes
- Develops Go concurrency through an RSS pipeline and practical guidance on coordination, cancellation, limits, and race testing.
- Examples
- Builds an RSS reader that fetches multiple feeds and passes articles to a saving function.
- What you can do after
- Builds concurrent Go workflows using goroutines, channels, cancellation, and synchronization.
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
- Introduces concurrency as a way to organize overlapping tasks for performance, scalability, and manageable system design.
- How deep it goes
- Develops concurrency from hardware and runtime abstractions through application patterns and a methodical system-design process.
- Examples
- Uses a cook juggling soup and salad, a server with waiting clients, and a pooled password-cracking program.
- What you can do after
- Practice designing a simple concurrent system and identifying flaws that reduce efficiency or scalability.
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 concurrency to keep low-latency applications responsive while long-running or I/O-bound operations are in progress.
- How deep it goes
- Develops execution models, Little’s law, synchronization costs, a benchmark, and monitoring guidance.
- Examples
- Uses request-count calculations and a ten-task simulated-delay benchmark to illustrate work in flight and overlapping waits.
- What you can do after
- Evaluate concurrency models and benchmark overlapping tasks against sequential execution.
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
- Frames concurrency as a Go design and diagnostic concern rather than a guarantee of faster execution.
- How deep it goes
- Explains scheduling and coordination, then contrasts parallel merge sort implementations and benchmarks.
- Examples
- Uses a coffee shop analogy and sequential versus parallel merge sort benchmarks.
- What you can do after
- Diagnose performance assumptions by benchmarking alternatives and choosing coordination and workload sizing appropriate to the task.
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
- Introduces concurrent application programming through threads, processes, task isolation, and Rust’s safety guarantees.
- How deep it goes
- Explains scheduling, isolation trade-offs, and thread scaling, while stopping short of implementing concurrency crates.
- Examples
- Uses a rejected shared-variable thread example and a six-core sleep-versus-spin benchmark.
- What you can do after
- Apply concurrency via Rust’s standard library and the crossbeam and rayon crates.
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
- Explains how overlapping database transactions affect isolation in a multiuser system.
- How deep it goes
- Defines four isolation problems and relates transaction duration and boundaries to concurrent access.
- Examples
- Illustrates lost updates with concurrent changes to an auction’s buy-now price.
- What you can do after
- Evaluate isolation problems and the tradeoff between isolation and scalability.
Read how Java Persistence with Spring Data and Hibernate epub explains concurrency →
The Coder Cafe
Concurrency is an execution model that structures tasks so they can be managed independently without requiring them to run simultaneously.
- How it is used
- Structures independent work to keep applications responsive while tasks wait or compete for resources.
- How deep it goes
- Works through the concurrency–parallelism distinction and coroutine resumption, then summarizes shared-resource and timing hazards without detailing their implementations.
- Examples
- Uses a coffee shop’s waiters and queues alongside a Python yield-and-next coroutine listing.
- What you can do after
- Evaluate/understand when independent task structure helps, whether parallel execution is necessary, and where coordination or timing can cause failures.
Microservices Patterns, Second Edition
Concurrency is the condition in which multiple operations or transactions execute during overlapping periods of time.
- How it is used
- Uses concurrency to address shared-data correctness risks and reduce query latency through parallel provider calls.
- How deep it goes
- Explains transaction risks and parallel service calls, but does not detail scheduling internals.
- Examples
- Uses createOrder state changes and findOrder provider calls to illustrate shared-data risks and parallel execution.
- What you can do after
- Apply concurrency by parallelizing independent provider calls and sequencing dependent calls.
Read how Microservices Patterns, Second Edition 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 I/O waits with other work in async applications.
- How deep it goes
- Demonstrates Tokio concurrency and scheduling through sleep tests while deferring detailed discussion of parallel execution.
- Examples
- Compares sequential awaits, joined tasks, and spawned tasks using blocking and nonblocking sleeps.
- What you can do after
- Apply it via Tokio to structure concurrent tasks and distinguish concurrency from parallel execution.
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 →
Functional Programming in C#, Second Edition
The execution of multiple computations during overlapping periods of time.
- How it is used
- Addresses predictable results when computations run concurrently, especially where they share mutable state.
- How deep it goes
- Contrasts in-place mutation with concurrent reads, then outlines independent computation and synchronization approaches.
- Examples
- Uses concurrent array sorting and summing, plus server counters, caches, and competing purchase requests.
- What you can do after
- Evaluate concurrent designs by identifying shared mutation and considering independent computations or synchronized access.
Read how Functional Programming in C#, Second Edition explains concurrency →
Test Driven: Practical TDD and Acceptance TDD for Java Developers
Concurrency is the overlapping progress of multiple computations.
- How it is used
- Uses concurrency to examine the testing challenges of unpredictable, multithreaded functionality.
- How deep it goes
- Works through test strategies and behavior targets, then briefly surveys Java synchronizer objects without detailing their internals.
- Examples
- Targets tests for shared-resource synchronization, blocking and unblocking, thread starts and stops, and asynchronous execution.
- What you can do after
- Apply test-driven development by isolating sequential logic, selecting concurrent failure scenarios, and testing key thread behaviors.
Read how Test Driven: Practical TDD and Acceptance TDD for Java Developers 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 →
Designing AI Systems
Concurrency is the management of multiple in-progress operations so that their execution can overlap without requiring simultaneous CPU execution.
- How it is used
- Coordinates workflow requests and independent child calls so waiting on platform services does not serialize the system.
- How deep it goes
- Explains event loops, worker processes, thread pools, fan-out, result ordering, and failure propagation through implementation examples.
- Examples
- Uses uvicorn workers, synchronous workflow threads, and a research assistant that queries papers, news, and patents in parallel.
- What you can do after
- Apply concurrency via asyncio, uvicorn workers, and `workflow.call_parallel()` to increase throughput and reduce independent-call latency.
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.
GPU Programming with Triton
Concurrency is the organization of multiple tasks so that their progress overlaps, often by interleaving work rather than executing tasks simultaneously.
- How it is used
- Organizes independent tasks so their progress overlaps, creating opportunities for parallel execution.
- How deep it goes
- Defines concurrency through task switching, contrasts it with simultaneous execution, and links it to GPU tile computation.
- Examples
- Uses a cashier switching between coffee orders and contrasts that with multiple cashiers serving customers simultaneously.
- What you can do after
- Understand how structuring independent tasks creates opportunities for multiple processors to execute them simultaneously.
Build a Multi-Agent System (from Scratch)
Concurrency is the coordination of multiple tasks whose execution can overlap in time.
- How it is used
- Keeps applications productive while tool calls wait and lets agent tasks run in the background for later awaiting.
- How deep it goes
- Explains asynchronous tool interfaces, coroutine and await mechanics, and agent task handling through implementation details.
- Examples
- Uses a weather API tool, an awaited Hailstone call, multiple tool calls, and concurrent agent tasks.
- What you can do after
- Apply it via Python async/await and asyncio to run waiting tool calls and agent tasks without blocking.
Read how Build a Multi-Agent System (from Scratch) explains concurrency →
Secrets of the JavaScript Ninja, Third Edition
Concurrency is the overlapping progress of multiple operations during the same period of execution.
- How it is used
- Coordinates concurrent asynchronous operations, such as fetching multiple sources before rendering a UI.
- How deep it goes
- Explains four Promise combinators through their outcome behavior and fetch examples.
- Examples
- Uses multiple post requests with Promise.all and a fetch timeout with Promise.race.
- What you can do after
- Apply Promise.all to combine concurrent fetches or Promise.race to enforce a timeout.
Read how Secrets of the JavaScript Ninja, Third Edition explains concurrency →
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.
Also covered in
- Type-Driven Development with Idris
- ASP.NET Core in Action, 3e
- Software Design for Python Programmers
- Object-Oriented Software Design in C++
- Distributed Machine Learning Patterns
- Just Use Postgres!
- Simple Object-Oriented Design: Create clean, maintainable applications
- The Well-Grounded Rubyist, Fourth Edition
- Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
- Writing for Developers: Blogs that get read
- Grokking Simplicity
- Embedded Software with RustIn early access (MEAP)
What to know first
- threadA thread is a distinct sequence of execution with its own control flow and state, managed or scheduled by a processor, runtime, or operating system.
- CPUA central processing unit (CPU) is a computer processor that executes program instructions and performs general-purpose computational operations.
- throughputThroughput is the rate at which a system processes or completes work, data, or requests over a specified period.
- GoGo is a statically typed, compiled, general-purpose programming language with garbage collection and built-in support for concurrency.
Related concepts
- parallelismcontrasts with · Parallelism is the execution of multiple independent tasks or computational operations at the same time rather than sequentially.
- sequential processingcontrasts with · Sequential processing is the execution of operations one after another in a defined order, without overlapping their execution.
- actorincludes · An actor is a person, system, process, or computational entity that performs actions or participates in interactions within a system.
- pipeline parallelismused by · Pipeline parallelism is a form of model parallelism that divides computation into sequential stages assigned to different devices, allowing multiple inputs or microbatches to progress through the stages concurrently.
- process typehas part · The book's Idris Process type describes computations that perform IO and protocol-governed message-passing operations.
Questions about concurrency
What is concurrency?
Concurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously.
Which Manning books explain concurrency?
Go in Action, Second Edition, Python Concurrency with asyncio, Grokking Concurrency, Elixir in Action, Third Edition, Learn Concurrent Programming with Go, C++ Concurrency in Action, Second Edition, Latency, Rust Servers, Services, and Apps and 23 more.
What should I know before learning concurrency?
Manning books that teach concurrency usually introduce thread, CPU, throughput and Go first.
What is the difference between concurrency and parallelism?
Concurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously. Parallelism is the execution of multiple independent tasks or computational operations at the same time rather than sequentially.
What kinds of concurrency are there?
Kinds of concurrency include actor.
What are the parts of concurrency?
Concurrency includes process type.
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.






























