← Back to catalog
Python Concurrency: Asyncio & Multiprocessing cover image
Python Advanced

Python Concurrency: Asyncio & Multiprocessing

Write high-throughput Python applications using event loops, thread pools, and process pools.

Instructor Gwen Tennyson
Duration 210 minutes (4 lessons)
Estimated Effort 3.5 hours total (1.75 hrs/week over 2 weeks)
Price USD 69.00
USD 69.00 Full Lifetime Access

Sign in to track your learning progress.

Course Overview

Understand GIL constraints, master `asyncio` task management, prevent race conditions, and leverage multi-core CPU scaling for parallel workloads.

What You Will Learn

Deconstruct the Python Event Loop, tasks, coroutines, and future objects
Bypass Global Interpreter Lock (GIL) limitations using `multiprocessing` and process pools
Manage thread pools safely with locking primitives, queues, and semaphores
Handle cancelled tasks, timeouts, and exception propagation in async gathering
Profile CPU-bound vs. I/O-bound bottlenecks to select optimal concurrency models

Tools & Technologies Used

Python 3.11 Asyncio Concurrent.Futures cProfile HTTPX

Structured Curriculum

2 Modules  ·  4 Lessons  ·  210 Minutes Total

Module 1

Module 1: Asyncio Event Loop & Non-Blocking I/O

2 lessons

Master async coroutines, task scheduling, and non-blocking I/O.

  • 📄

    Event Loop Internals & Task Execution

    Understand how the event loop multiplexes socket I/O without OS threads.

    Deep Dive 50 min
  • 📄

    Gathering Tasks, Semaphores & Timeouts

    Execute 100+ concurrent API requests safely using `asyncio.Semaphore`.

    Code Workshop 55 min
Module 2

Module 2: Multiprocessing, Threading & GIL Bypass

2 lessons

Utilize multi-core CPUs for heavy computations and manage shared state.

  • 📄

    ProcessPoolExecutor vs. ThreadPoolExecutor

    Delegate CPU-bound math to worker processes and I/O tasks to thread pools.

    Hands-on Exercise 50 min
  • 📄

    Concurrency Debugging & Race Condition Prevention

    Spot deadlocks, race conditions, and unhandled async exception warnings.

    Debugging Lab 55 min

Practical Project & Capstone Outcome

🚀 Capstone Project

High-Throughput Concurrent Web Scraper & Parser Engine

Build an async web scraping service that fetches thousands of pages via `asyncio` and processes HTML parsing across multi-core process pools.

Prerequisites

  • Python intermediate proficiency (functions, classes, exception handling)

Intended Audience

  • Backend Developers building high-concurrency web services and scrapers
  • Systems Engineers optimizing CPU-heavy Python data tools

Instructor Information

G

Gwen Tennyson

Course Author & Industry Expert

Gwen Tennyson is a Senior Python Core Systems Engineer who has architected high-concurrency infrastructure for streaming applications.

Frequently Asked Questions

Does Python 3.13 free-threaded (no-GIL) build affect this material?

The course covers both standard GIL mechanics and how future free-threading models interact with process pools.