Python Concurrency and Parallel Programming

4.

Asynchronous Programming with asyncio

4.1.

Asynchronous Programming Concepts

4.1.1.

Cooperative Multitasking

4.1.1.1.

Voluntary yielding control

4.1.1.2.

Task scheduling principles

4.1.1.3.

Execution flow management

4.1.2.

Event Loop Architecture

4.1.2.1.

Event loop responsibilities

4.1.2.2.

Loop execution model

4.1.2.3.

Loop lifecycle management

4.1.3.

Coroutine Fundamentals

4.1.3.1.

Coroutine definition and behavior

4.1.3.2.

Coroutine state management

4.1.3.3.

Coroutine vs generator differences

4.1.4.

Non-Blocking Operations

4.1.4.1.

Awaitable object types

4.1.4.2.

Blocking call avoidance

4.1.4.3.

I/O operation handling

4.2.

Asyncio Core Components

4.2.1.

Async and Await Syntax

4.2.1.1.

Asynchronous function definition

4.2.1.2.

Await expression usage

4.2.1.3.

Syntax rules and constraints

4.2.2.

Coroutine Function Definition

4.2.2.1.

Async def syntax

4.2.2.2.

Return value handling

4.2.2.3.

Parameter passing

4.2.3.

Event Loop Management

4.2.3.1.

Running with asyncio.run()

4.2.3.2.

Loop creation and destruction

4.2.3.3.

Loop policy configuration

4.3.

Concurrent Task Management

4.3.1.

4.3.1.1.

Creating tasks with create_task()

4.3.1.2.

Task object properties

4.3.1.3.

Task cancellation mechanisms

4.3.2.

Concurrent Execution Patterns

4.3.2.1.

Gather Operations

4.3.2.1.1.

Result aggregation

4.3.2.1.2.

Exception handling

4.3.2.1.3.

Return value ordering

4.3.2.2.

Wait Operations

4.3.2.2.1.

Completion waiting strategies

4.3.2.2.2.

Timeout handling

4.3.2.2.3.

Return conditions

4.3.2.3.

As Completed Processing

4.3.2.3.1.

Result processing as available

4.3.2.3.2.

Iterator-based consumption

4.3.2.3.3.

Progress tracking

4.4.

Asyncio Synchronization Primitives

4.4.1.

4.4.1.1.

Mutual exclusion in coroutines

4.4.1.2.

Lock acquisition patterns

4.4.1.3.

Context manager support

4.4.2.

4.4.2.1.

Coroutine signaling

4.4.2.2.

Event state management

4.4.2.3.

Waiting patterns

4.4.3.

Asyncio Conditions

4.4.3.1.

Complex coordination scenarios

4.4.3.2.

Wait and notify operations

4.4.3.3.

Predicate-based waiting

4.4.4.

Asyncio Semaphores

4.4.4.1.

Concurrent access limiting

4.4.4.2.

Resource management

4.4.4.3.

Acquisition counting

4.5.

Asynchronous Data Structures

4.5.1.

4.5.1.1.

Producer-consumer patterns

4.5.1.2.

Queue operation methods

4.5.1.3.

Backpressure handling

4.5.1.4.

Queue size management

4.6.

Network Programming with Asyncio

4.6.1.

Stream Connections

4.6.1.1.

TCP connection establishment

4.6.1.2.

Connection management

4.6.1.3.

Stream reading and writing

4.6.2.

Server Implementation

4.6.2.1.

Asynchronous server creation

4.6.2.2.

Client handling patterns

4.6.2.3.

Server lifecycle management

4.7.

Blocking Code Integration

4.7.1.

Executor Integration

4.7.1.1.

Thread pool executor usage

4.7.1.2.

Process pool executor usage

4.7.1.3.

Blocking call offloading

4.7.1.4.

Result handling patterns

Previous

3. Multiprocessing for CPU-Bound Parallelism

Go to top

Next

5. High-Level Abstractions with concurrent.futures