Blocking
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.
Python Concurrency with asyncio
A socket operating mode in which an application waits for an I/O operation to complete before continuing.
- How it is used
- Diagnoses why synchronous applications, socket servers, and asyncio tasks become unresponsive during slow I/O.
- How deep it goes
- Explains blocking from application behavior through socket calls and event-loop effects, then defers implementation to non-blocking libraries and threads.
- Examples
- Demonstrates frozen applications, a two-client echo server, requests.get, time.sleep, aiohttp, and sync_to_async.
- What you can do after
- Diagnose blocking calls and choose non-blocking libraries or thread-based bridges for responsive asynchronous applications.
Read how Python Concurrency with asyncio explains blocking →
Rust Servers, Services, and Apps
A blocking operation is an operation that prevents its executing thread or task from continuing until an external activity completes.
- How it is used
- Motivates choosing synchronous execution, operating system threads, or async scheduling for tasks that wait on external work.
- How deep it goes
- Defines blocking through thread waits and works through simulated delays and threaded code; does not examine operating system I/O internals.
- Examples
- Uses sequential simulated file reads with four- and two-second sleeps, then runs them on separate operating system threads.
- What you can do after
- Diagnose/debug with it by identifying waits that hold up a thread and comparing sequential execution with separate-thread execution.
Read how Rust Servers, Services, and Apps explains blocking →
C# Concurrency: Asynchronous and multithreaded programming
A blocking operation is an operation that prevents its thread from making progress while waiting for external data, another thread, or another condition.
- How it is used
- Explains why waiting on files, networks, and threads consumes resources and motivates asynchronous programming.
- How deep it goes
- Defines operating-system blocking, thread costs, and thread-pool effects, then stops short of low-level implementation details.
- Examples
- Uses file and network access, camera capture, mail sending, Task.Wait, Task.Result, Task.Delay, and thread-pool benchmarks.
- What you can do after
- Diagnose blocked threads and choose asynchronous APIs when workloads spend most of their time waiting.
Read how C# Concurrency: Asynchronous and multithreaded programming explains blocking →
Grokking Concurrency
Blocking is a condition in which a task or operation cannot make progress until a required event, resource, or I/O operation completes.
- How it is used
- Explains how waiting operations affect processor use, concurrent tasks, and server responsiveness.
- How deep it goes
- Defines blocking I/O and distinguishes it from synchronous control flow, without detailing all four I/O models.
- Examples
- Uses waiting for pizza to cook and socket calls such as send() and recv() as examples.
- What you can do after
- Understand why blocking I/O can leave a processor idle or make an event loop unresponsive.
Quarkus in Action
A blocking operation is an operation that prevents its executing thread from performing other work until the operation completes.
- How it is used
- Frames blocking as a practical constraint when integrating I/O and message handlers with reactive Quarkus applications.
- How deep it goes
- Explains thread occupancy, event-loop consequences, warnings, and channel or annotation-based mitigation without detailing scheduler internals.
- Examples
- Uses database, filesystem, network, and broker I/O plus a sleeping payment consumer as concrete blocking examples.
- What you can do after
- Apply it via Quarkus messaging by isolating waiting work on a channel and annotating the handler with @Blocking.
Code Like a Pro in Rust
A blocking operation is an operation that prevents an asynchronous runtime from switching tasks for a significant period.
- How it is used
- Identifies work that prevents an async runtime from switching tasks during I/O waits or long CPU-bound operations.
- How deep it goes
- Defines blocking by its effect on scheduling and explains yield points, but gives no universal duration threshold.
- Examples
- Contrasts one-second `std::thread::sleep` with an awaited Tokio timer and uses a 1,024-byte I/O timing command.
- What you can do after
- Apply it via Tokio’s awaited timer to create a scheduler yield opportunity instead of sleeping the thread.
Refactoring to Rust
Blocking is execution behavior in which a process cannot proceed until a required resource or operation becomes available.
- How it is used
- Uses blocking to identify synchronous bottlenecks in image generation and data requests before introducing asynchronous processing.
- How deep it goes
- Defines blocking through process and request waiting, then contrasts it with asynchronous processing without explaining scheduler internals.
- Examples
- Uses a Python Mandelbrot image loop, concurrent process commands, and an asynchronous Rust search request as concrete examples.
- What you can do after
- Diagnose synchronous waits and choose asynchronous processing when independent work should continue without waiting for responses.
Go in Action, Second Edition
A blocking I/O operation prevents the calling execution flow from progressing until input or output completes.
- How it is used
- Uses blocking network waits to motivate concurrency for independent feed retrieval and responsive applications.
- How deep it goes
- Demonstrates synchronous ParseURL calls and moves them into goroutines, without detailing blocking internals or synchronization mechanisms.
- Examples
- Uses New York Times and BBC RSS requests parsed through gofeed.ParseURL.
- What you can do after
- Apply it via Go goroutines to overlap independent network or disk waits with other work.
Akka in Action, Second Edition
Blocking I/O is input or output whose calling execution path waits until the operation completes or fails.
- How it is used
- Frames blocking I/O as a traditional scaling mechanism whose synchronous waits complicate thread, RPC, and database coordination.
- How deep it goes
- Explains blocking I/O through database drivers, RPCs, lock interactions, and access-flow risks, but stops short of implementation internals.
- Examples
- Uses JDBC, DAO calls, and a team-chat message flow to illustrate blocking database access.
- What you can do after
- Evaluate how synchronous database calls and RPCs can create coordination, deadlock, and scaling risks.
Related concepts
- asynchronous programmingcontrasts with · 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.
- non-blocking I/Ocontrasts with · Non-blocking I/O is an input/output technique in which an operation returns control without requiring the initiating activity to wait for its completion.
- multithreadingaddressed by · 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.
- threaduses · A thread is an independently schedulable sequence or context of execution within a program or process.
- answer criticincludes · An answer critic is a component that evaluates whether a retrieved answer correctly and completely answers the original question and can prevent unsupported answers from being returned.
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.