1import threading
2import time
3
4def download(url):
5    print(f"Downloading {url}...")
6    time.sleep(2)  # Simulate network I/O
7    print(f"Finished {url}")
8
9def process_data(data):
10    print(f"Processing {data}...")
11    time.sleep(3)
12    print(f"Finished processing {data}")
13
14# Create threads
15t1 = threading.Thread(target=download, args=("https://example.com",))
16t2 = threading.Thread(target=process_data, args=("dataset.csv",))
17
18# Start both
19t1.start()
20t2.start()
21
22# Wait for both to finish
23t1.join()
24t2.join()
25print("All tasks complete")  # Runs after ~3 seconds, not 5

1from multiprocessing import Process, Pool
2import os
3
4def compute_heavy(n):
5    """CPU-intensive calculation"""
6    result = sum(i * i for i in range(n))
7    print(f"PID {os.getpid()}: result = {result}")
8    return result
9
10# Option 1: Process objects
11p1 = Process(target=compute_heavy, args=(10_000_000,))
12p2 = Process(target=compute_heavy, args=(20_000_000,))
13p1.start()
14p2.start()
15p1.join()
16p2.join()
17
18# Option 2: Pool for mapping over inputs
19with Pool(processes=4) as pool:
20    results = pool.map(compute_heavy, [1_000_000, 2_000_000, 3_000_000, 4_000_000])
21    print(results)

1import asyncio
2import aiohttp
3
4async def fetch(session, url):
5    async with session.get(url) as response:
6        data = await response.text()
7        print(f"Fetched {url}: {len(data)} chars")
8        return data
9
10async def compute(name, duration):
11    print(f"Starting {name}")
12    await asyncio.sleep(duration)
13    print(f"Finished {name}")
14    return name
15
16async def main():
17    # Run multiple async functions concurrently
18    results = await asyncio.gather(
19        compute("task_a", 2),
20        compute("task_b", 3),
21        compute("task_c", 1),
22    )
23    print(results)  # ['task_a', 'task_b', 'task_c'] after ~3 seconds
24
25asyncio.run(main())

1from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
2
3def task(name, duration):
4    import time
5    time.sleep(duration)
6    return f"{name} done"
7
8# ThreadPoolExecutor for I/O-bound work
9with ThreadPoolExecutor(max_workers=4) as executor:
10    futures = {
11        executor.submit(task, "download", 2): "download",
12        executor.submit(task, "upload", 3): "upload",
13        executor.submit(task, "query", 1): "query",
14    }
15    for future in as_completed(futures):
16        print(future.result())
17
18# ProcessPoolExecutor for CPU-bound work — same API
19with ProcessPoolExecutor(max_workers=4) as executor:
20    results = list(executor.map(compute_heavy, [1_000_000, 2_000_000]))

1async function fetchData(url) {
2  const response = await fetch(url);
3  return response.json();
4}
5
6async function processAll() {
7  // Run all three in parallel
8  const [users, posts, comments] = await Promise.all([
9    fetchData("/api/users"),
10    fetchData("/api/posts"),
11    fetchData("/api/comments"),
12  ]);
13  console.log(users, posts, comments);
14}
15
16// Promise.allSettled — does not reject on individual failures
17const results = await Promise.allSettled([
18  fetchData("/api/users"),
19  fetchData("/api/broken"),  // This fails but doesn't kill the others
20]);

1package main
2
3import (
4    "fmt"
5    "sync"
6    "time"
7)
8
9func download(url string, wg *sync.WaitGroup) {
10    defer wg.Done()
11    fmt.Printf("Downloading %s...\n", url)
12    time.Sleep(2 * time.Second)
13    fmt.Printf("Finished %s\n", url)
14}
15
16func main() {
17    var wg sync.WaitGroup
18
19    urls := []string{"url1", "url2", "url3"}
20    for _, url := range urls {
21        wg.Add(1)
22        go download(url, &wg)
23    }
24
25    wg.Wait()
26    fmt.Println("All downloads complete")
27}