---
title: 'Python Async Await EXPLAINED | Run 1000 Tasks on ONE Thread | asyncio Tutorial | Ep 25'
source: 'https://youtube.com/watch?v=u2MOKaEcsCc'
video_id: 'u2MOKaEcsCc'
date: 2026-06-15
duration_sec: 641
---

# Python Async Await EXPLAINED | Run 1000 Tasks on ONE Thread | asyncio Tutorial | Ep 25

> Source: [Python Async Await EXPLAINED | Run 1000 Tasks on ONE Thread | asyncio Tutorial | Ep 25](https://youtube.com/watch?v=u2MOKaEcsCc)

## Summary

This video explains Python's async/await syntax and the asyncio library for running thousands of I/O-bound tasks concurrently on a single thread. It covers coroutines, the event loop, gather, create_task, async context managers, and production patterns like timeouts and semaphores. The tutorial culminates in building a concurrent API fetcher with rate limiting.

### Key Points

- **Coroutines are defined with async def** [00:51] — Calling an async function returns a coroutine object, not executing the code immediately. To run it, you need await.
- **Await pauses and yields control** [01:21] — Inside a coroutine, await pauses the current task and lets the event loop run other code. When the awaited operation finishes, execution resumes.
- **asyncio.run is the entry point** [01:52] — It creates a new event loop, runs the main coroutine, and closes the loop. Call it exactly once at the top level of your program.
- **asyncio.gather runs tasks concurrently** [02:53] — Pass multiple coroutines to gather; they start immediately and run concurrently. Total time equals the slowest task, not the sum.
- **asyncio.create_task for background work** [03:50] — Schedules a coroutine to run immediately without waiting. Use await later to collect the result.
- **Async context managers with __aenter__ and __aexit__** [04:51] — Define async methods for setup and cleanup. Use 'async with' to ensure non-blocking resource management.
- **Timeouts with asyncio.wait_for** [05:46] — Wrap a coroutine with a timeout. If it doesn't finish in time, asyncio.TimeoutError is raised.
- **Limiting concurrency with asyncio.Semaphore** [06:02] — Create a semaphore with a fixed limit. Use 'async with sem' before each operation to control how many run at once.
- **Async iteration with async for** [06:19] — An async generator yields values one at a time, awaiting between each. Useful for streaming data.
- **Mini project: concurrent API fetcher** [07:40] — Combines semaphore, gather, and async context manager to fetch many URLs concurrently while respecting rate limits.

### Conclusion

Async/await in Python allows you to run thousands of I/O-bound tasks concurrently on a single thread using cooperative multitasking. Mastering asyncio's core tools—coroutines, gather, create_task, async context managers, timeouts, and semaphores—enables building high-performance concurrent applications.

## Transcript

Your program freezes for a full second
on every network call. Your loop
processes earl painfully slow. Every
blocking call weighs time just sitting
and waiting. I am Mahas. Today in
episode 25, async Python, you will learn
how to run thousands of operations
concurrently without threads. We will
cover async defaf and await. How co-
routines actually work. Assentio.run and
the event loop. Assessio.Gather for
running tasks concurrently.
Assencio.create
task for scheduling background work.
Async context managers using dunder
enter and dunder exit and real
production patterns timeouts semaphors
and async iteration. By the end you will
have a full concurrent API fetcher with
a semaphore rate limit. Let's go. A
co-ine is a function defined with async
defaf. Calling it does not run the code.
It creates a co-outine object. Let's
understand what happens under the hood.
Look at the code. On the left, we define
a regular function fetch data. Calling
fetch data executes immediately and
returns a value. On the right, we define
the same function with async defaf.
Calling fetch data now returns a
co-outine object. Nothing is run yet. To
actually run it, you need a wait. But a
wait only works inside another async
function. Inside the corine, a wait
essenti. pauses this task and lets the
event loop run other code. When the
sleep finishes, execution resumes
exactly where it left off. Async defaf
creates a co-ine. A wait is what
actually runs it and gives you the
result. This pause and resume mechanism
is the foundation of every async pattern
in Python. Every async program needs an
entry point. That's essenti.run. Look at
the code. We define an async function
called main. Inside main, we print
hello. Then a weight essenti
of 1 second. This is non-blocking. The
event loop is free during this weight.
Then we print world. At the bottom,
essenti
is the entry point. It creates a brand
new event loop. runs the main co-
routine until it completes and then
closes the loop automatically. You call
essentio.run
exactly once at the top level of your
program never inside another corine and
never nested. The event loop is the
engine that schedules every corine call
back and timer. Asiosleep does not block
the thread. It tells the loop come back
to me later. This is the core mental
model. One loop, many co- routines,
cooperative pausing. Now let's run
multiple co- routines at the same time.
Look at the code on the left. Sequential
await. We await fetch of one, then fetch
of two, then fetch of three. Each takes
1 second and a wait blocks until each
finishes before starting the next. Total
time about 3 seconds. On the right,
concurrent with Asencio.
We pass all three co- routines to
essentiate
the whole thing at once. All three start
immediately and run concurrently. Total
time about 1 second. The time of the
slowest task, not the sum.
Assentio.gather
returns the results as a list in in the
same order you pass the corines in,
regardless of which one finishes first.
This is the single biggest performance
win in async code. Independent IO
operations should almost always run with
gather not sequential await. Asio.create
task lets you start a co- routine
running in the background immediately
without waiting for it. Look at the
code. We define a worker function that
sleeps for a delay then prints done.
Inside main, we call essentio.create
task for worker A with a 2-cond delay.
and again for worker B with a 1second
delay. Both lines return immediately.
The tasks are scheduled but main keeps
running. We print both started right
away. Then we await T1 and await T2 to
collect their results. Even though A was
created first, B finishes first because
B's delay is shorter. The scheduling
order is not the completion order.
Create underscore task is how you fire
off work now and collect the result
later. Perfect for background jobs,
logging or fire and forget operations
you still want to track. Some resources
need asynchronous setup and cleanup
database connections, network sessions,
locks. That's what async with is for.
Look at the code. We define an async
connection class. Dunder enter is an
async method. It awaits connect_b
to open the connection and returns it.
Dunder exit is also async. It awaits the
connections close method to clean up
inside main async with async connection
open perin close pin as con gives us the
connection object. We await conexecute
inside the block when the block exits
even if an exception occurs. Dunder exit
runs automatically and the connection
closes. Async with is the asynchronous
version of the regular with statement.
same guarantee of cleanup, but every
step can be in non-blocking await.
You'll see this pattern in database
drivers, HTTP client sessions, and
distributed locks. Let's look at three
productionready async patterns. First,
timeouts with essentio.we_4.
Wrap any co- routine with a timeout in
seconds. If it doesn't finish in time,
essenti
error is raised. Catch it and return a
fall back. Second limiting concurrency
with essentio.seaphore.
Create a semaphore with a fixed limit.
Then async with sim before each
operation only that many operations run
at once. Everything else waits its turn.
This prevents overwhelming a server with
thousands of simultaneous requests.
Third, async iteration with async 4. An
async generator yields values one at a
time awaiting between each. Perfect for
streaming lines from a file or
pageionated API results. All three
patterns combine, a semaphore limited
timeout protected async generator is the
backbone of any serious data pipeline.
Asio ships with several essential tools.
Let's cover the four most important
ones. First, as Entios sleep, a
non-blocking pause. It yields control
back to the event loop instead of
freezing the thread. Second,
essentio.weight_4
runs a co- routine with a timeout
raising timeout error if it's too slow.
Third essentio.task
group available in Python 311 and later.
Structured concurrency create tasks
inside the group and if any task raises
all other tasks are automatically
canled. Fourth, essentio.q an async safe
producer consumer queue. Producers
await, put, consumers await, get. These
four tools handle pausing, timeouts,
structure concurrency, and inter task
communication. Use them before reaching
for threads or third party async
libraries. Our mini project, a
concurrent API fetcher with a semaphore
rate limit. This is the pattern used in
every production data pipeline. Look at
the code. We define an async fetch
function that takes a session, a URL,
and a semaphore. Async with sim limits
how many requests run at once. Inside
async with session get awaits the
response and returns the JSON. Fetch_all
creates a semaphore with a given limit,
opens one a client session, builds a
list of fetch co- routines, one per URL,
and awaits a cinio. rather on all of
them at once. We call Asenio.run
with limit equals 10, meaning up to 10
requests run concurrently. The rest Q
automatically. This single pattern can
fetch thousands of Earls, respect a
server's rate limits, and finish in a
fraction of the time sequential code
would take. Your challenge, build an
async pipeline from scratch. Step one,
write an async fetch user function that
takes an ID, awaits a centio. To
simulate network delay, and returns a
fake user dict. Step two, use
essentio.gather to fetch 10 users
concurrently and print the total elapse
time. Step three, wrap the gather call
with an essentio.
of three so only three fetches run at
once. Compare the timing. Step four,
write an async context manager called
timer that prints elapse time on exit
using dunder enter and dunder exit. Step
five, combine everything into one async
main function and run it with
essentio.run. Paste your full pipeline
and the timing output in the comments. I
read every single one. Let's recap what
you learned today. Async defaf defines a
co- routine. Calling it returns an
object it doesn't run yet. Await runs a
co- routine and pauses until the result
is ready, yielding control to the event
loop. Assentio.run is the entry point.
It creates runs and closes the event
loop call at once. Assencio.gather runs
many corines concurrently. Total time is
roughly the slowest one, not the sum.
Assentio.create
task schedules work immediately. Await
it later for the result. Async width,
dunder enter, and dunder exit handle
asynchronous setup and cleanup. Wait
underscore for ads timeouts and
semaphore limits concurrency. The mini
project built a concurrent API fetcher
with a rate limiting semaphore. Next
episode, context managers with dunder
enter, dunder exit, and context slip.
Subscribe so you don't miss it. See you
tomorrow. Async mastered. Your Python
code now runs concurrently without
blocking on a single IO call. Subscribe
for the next episode. Drop your async
pipeline in the comments. I am Aas. See
you in episode 26.