liveBook · Manning

Concurrency

Also called concurrent execution

Concurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously.

How 31 Manning books explain it

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.

Read how Grokking Concurrency explains concurrency →

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.

Read how Latency explains concurrency →

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.

Read how Refactoring to Rust explains concurrency →

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.

Read how Go by Example explains concurrency →

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.

Read how The Coder Cafe explains concurrency →

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.

Read how Code Like a Pro in Rust explains 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 →

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.

Read how Designing AI Systems 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.

Read how Kotlin in Action, 2E explains concurrency →

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.

Read how GPU Programming with Triton explains concurrency →

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.

Read how Think Distributed Systems explains concurrency →

Also covered in

What to know first

Related concepts

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.