asyncio అనేది Python యొక్క async/await ఉపయోగించి concurrent I/O కోసం ఫ్రేమ్వర్క్. ఇది event loop ద్వారా ఒకే thread పై అనేక I/O కార్యకలాపాలను సహకారంగా నిర్వహిస్తుంది — అధిక concurrent I/O-bounded పని (నెట్వర్క్ కాల్లు, వెబ్ సర్వర్లు) కోసం చిత్రమైనది threads యొక్క overhead లేకుండా.
import asyncio
async def fetch_data(id): # an async function = a coroutine
print(f"start {id}")
await asyncio.sleep(1) # await a non-blocking I/O operation (yields control)
print(f"done {id}")
return id
asyncio.run(fetch_data(1)) # run a coroutine from sync code
async def ఫంక్షన్ ఒక coroutine; await ఆ I/O బిందువు వద్ద దానిని నిలిపివేస్తుంది, event loop ఇతర coroutines నిర్వహించడానికి అనుమతిస్తుంది — ఆ తర్వాత అదే ఆపరేషన్ పూర్తయినప్పుడు తిరిగి ప్రారంభమవుతుంది.
# ❌ sequential — total time ≈ 3 seconds
async def slow():
await fetch_data(1) # wait 1s
await fetch_data(2) # then wait 1s
await fetch_data(3) # then wait 1s
# ✅ concurrent — total time ≈ 1 second (all run together)
async def fast():
await asyncio.gather(fetch_data(1), fetch_data(2), fetch_data(3))
asyncio.gather coroutines ను concurrently నిర్వహిస్తుంది — ఒకటి I/O కోసం ఎదురుచూస్తుండగా, ఇతరులు ముందుకు వెళ్లాయి. మూడు 1-సెకన్ వేచుంటారు ~1 సెకన్ మొత్తంగా అతిక్రమణ చేస్తారు. ఇదే ప్రధాన విలువ: ఒక thread పై అనేక I/O వేచుందలను అతిక్రమణ చేయడం.
Threading: OS-managed, preemptive, real threads (GIL-limited for CPU)
asyncio: single thread, COOPERATIVE — coroutines yield at `await` points
→ lighter weight (handle thousands of connections), no thread overhead,
but one CPU-heavy coroutine blocks everything (no preemption)
async def bad():
time.sleep(5) # ❌ BLOCKS the whole event loop (sync sleep)
result = heavy_compute() # ❌ CPU work freezes all coroutines
async def good():
await asyncio.sleep(5) # ✅ non-blocking
# offload CPU work to a thread/process pool
await loop.run_in_executor(None, heavy_compute)
ఇది సహకారం మరియు single-threaded కాబట్టి, ఏదైనా blocking/CPU-heavy కాల్ అన్ని coroutines ను హిమాయితం చేస్తుంది. await-able async API లను ఉపయోగించండి, మరియు blocking/CPU పనిని executor కు బదిలీ చేయండి.
✓ High-concurrency I/O: web servers (FastAPI), web scraping, many API/DB calls,
websockets, real-time apps — thousands of concurrent connections efficiently
✗ CPU-bound work — use multiprocessing instead (asyncio doesn't help)
asyncio అనేది Python లో high-concurrency I/O కోసం ఆధునిక విధానం, FastAPI వంటి ఫ్రేమ్వర్క్లను శక్తిशાली చేస్తుంది మరియు ఒక thread పై వేలాదిమందల ఏకకాల కనెక్షన్లను సమర్థవంతంగా నిర్వహించడానికి అనుమతిస్తుంది — thread-per-connection కంటే చాలా తేలికైనది.
Coroutines, await, gather ద్వారా concurrent execution, మరియు ముఖ్యంగా కీ నియమం (event loop ను నిరోధించవద్దు; CPU/blocking పనిని బదిలీ చేయండి) ను అర్థం చేసుకోవడం performant async Python ను రాయడానికి అవసరం.
ఇది ఎప్పుడు సరిపోతుంది (I/O-bounded concurrency) విరుద్ధంగా ఎప్పుడు లేదు (CPU-bounded → multiprocessing) చేరుకోవడం దీన్ని సమర్థవంతంగా ఉపయోగించడానికి కీలకం.