Learning Python - Concurrency & Parallelism

#Introduction

Applications that handle many things at once are a real need. Episode 15 dissects Python's three concurrency approaches: threading, multiprocessing, and asyncio. Each has its own model, strengths, and pitfalls.

We'll also learn modern async patterns with asyncio.TaskGroup in Python 3.11 plus alternatives like trio and anyio. With this understanding, you can pick the right approach for each problem.

#Understanding I/O-bound vs CPU-bound

#The Key to Choosing an Approach

Before choosing a concurrency tool, recognize the type of workload:

Membedakan beban kerja

import time
 
def io_bound():
    time.sleep(1)
 
def cpu_bound():
    total = 0
    for i in range(10_000_000):
        total += i
    return total

time.sleep(1) simulates I/O work — waiting on network or disk. A large loop simulates CPU work. I/O-bound fits threading and asyncio; CPU-bound fits multiprocessing. Choosing the wrong approach makes your application slow even with concurrency.

#Threading

#The Model and Its Limits

Threading runs within one process and shares memory, but is limited by the GIL for CPU code:

Threading untuk I/O-bound

import threading
import time
 
def kerja(nama):
    time.sleep(1)
    print(f"{nama} selesai")
 
mulai = time.perf_counter()
t1 = threading.Thread(target=kerja, args=("A",))
t2 = threading.Thread(target=kerja, args=("B",))
t1.start()
t2.start()
t1.join()
t2.join()
print(time.perf_counter() - mulai)

threading.Thread(target=kerja, args=("A",)) creates a new thread. Because time.sleep releases the GIL, two threads finish their work concurrently — total time far below 2 seconds. For I/O-bound work, threading is effective.

#Multiprocessing

#Getting Around the GIL

Multiprocessing uses separate processes, each with its own interpreter:

Multiprocessing untuk CPU-bound

from multiprocessing import Pool
 
def hitung(n):
    total = 0
    for i in range(n):
        total += i
    return total
 
if __name__ == "__main__":
    with Pool(4) as pool:
        hasil = pool.map(hitung, [10_000_000] * 4)
    print(hasil)

with Pool(4) as pool: creates four processes. pool.map distributes the work. Unlike threads, processes have their own GIL, so CPU computation runs in parallel. Note the if __name__ == "__main__" guard, which is required for multiprocessing on many systems.

#asyncio

#Event Loop and Coroutines

asyncio runs many tasks in a single thread using an event loop:

asyncio dasar

import asyncio
 
async def kerja(nama):
    await asyncio.sleep(1)
    return f"{nama} selesai"
 
async def utama():
    hasil = await asyncio.gather(
        kerja("A"),
        kerja("B"),
        kerja("C"),
    )
    print(hasil)
 
asyncio.run(utama())

async def kerja(nama) defines a coroutine and await asyncio.sleep(1) pauses without blocking. asyncio.gather runs many coroutines concurrently. asyncio.run(utama()) starts the event loop. This model is very efficient for thousands of concurrent connections.

#TaskGroups in Python 3.11

#Better Task Management

Python 3.11 introduced asyncio.TaskGroup to manage a group of tasks in a structured way:

Menggunakan TaskGroup

import asyncio
 
async def kerja(nama):
    await asyncio.sleep(1)
    return f"{nama} selesai"
 
async def utama():
    async with asyncio.TaskGroup() as grup:
        tugas = [grup.create_task(kerja(nama)) for nama in ["A", "B", "C"]]
    for t in tugas:
        print(t.result())
 
asyncio.run(utama())

async with asyncio.TaskGroup() as grup: creates a task group. grup.create_task(...) adds tasks that run concurrently. The async with block waits for all of them to finish, and cancels everything if one fails — much better error management than gather.

#Alternatives: trio and anyio

#anyio for Portability

anyio provides a single API that runs on top of both asyncio and trio:

pip install anyio

anyio bekerja di dua backend

import anyio
 
async def kerja(nama):
    await anyio.sleep(1)
    print(f"{nama} selesai")
 
async def utama():
    async with anyio.create_task_group() as grup:
        grup.start_soon(kerja, "A")
        grup.start_soon(kerja, "B")
 
anyio.run(utama)

anyio.create_task_group() creates a task group that can run on any backend. FastAPI and Starlette use anyio, so you can choose a backend without changing the API. This is a good portability investment.

#Closing

Key takeaways:

• Threading is effective for I/O-bound work because the GIL is released while waiting.
• Multiprocessing uses separate processes to bypass the GIL.
• asyncio runs many coroutines in a single thread.
• TaskGroup in Python 3.11 manages task groups with safe cancellation.
• anyio provides a single API that runs on both asyncio and trio.
• Choose an approach based on workload type: I/O-bound or CPU-bound.

In the next episode, episode 16, we'll cover performance tuning and profiling — profilers like cProfile and pyinstrument, sampling profilers and flame graphs, hot path optimization, native extensions with Cython, and when to use PyPy. Your application will run much faster!