1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// Model 1: Thread-per-request (Traditional)
// Used by: Apache (prefork), older Java servlets
class ThreadPerRequestServer {
    handleConnection(socket: Socket) {
        // Each request gets a dedicated thread
        const thread = new Thread(() => {
            const request = socket.read();
            const response = this.processRequest(request);
            socket.write(response);
        });
        thread.start();
    }
}
// Pros: Simple model, easy to reason about
// Cons: Memory overhead (~1MB per thread), limited to ~10K concurrent
 
// Model 2: Thread pool (Improved)
// Used by: Tomcat, most Java frameworks
class ThreadPoolServer {
    private pool = new ThreadPool(200);  // Fixed size
    
    handleConnection(socket: Socket) {
        this.pool.submit(() => {
            const request = socket.read();
            const response = this.processRequest(request);
            socket.write(response);
        });
    }
}
// Pros: Bounded resource usage, good utilization
// Cons: Still limited by thread count, blocking I/O wastes threads
 
// Model 3: Event-driven async (Modern)
// Used by: Node.js, Nginx, Go, Rust async
class EventDrivenServer {
    private eventLoop = new EventLoop();
    
    async handleConnection(socket: Socket) {
        const request = await socket.readAsync();  // Non-blocking!
        const response = await this.processRequestAsync(request);
        await socket.writeAsync(response);
        // Thread returns to pool during I/O, handles other requests
    }
}
// Pros: Millions of concurrent connections possible
// Cons: More complex programming model, callback/promise chains

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

-- Transaction 1: Transfer funds
BEGIN TRANSACTION;
UPDATE accounts SET balance = balance - 100 WHERE id = 'A';
UPDATE accounts SET balance = balance + 100 WHERE id = 'B';
COMMIT;
 
-- Transaction 2: Check account balance (concurrent)
BEGIN TRANSACTION;
SELECT balance FROM accounts WHERE id = 'A';
-- What value does this see?
-- Before T1? During T1? After T1?
COMMIT;
 
-- Transaction 3: Also transferring from A (concurrent)
BEGIN TRANSACTION;
UPDATE accounts SET balance = balance - 50 WHERE id = 'A';
-- Both T1 and T3 read A's balance, then write a new value
-- Without proper concurrency control: LOST UPDATE bug
COMMIT;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// iOS/Swift approach
class PhotoViewController {
    func loadPhoto(id: String) {
        // Show loading state immediately on main thread
        self.showLoadingSpinner()
        
        // Heavy work on background thread
        DispatchQueue.global(qos: .userInitiated).async {
            // This runs on a background thread
            let photoData = self.downloadPhoto(id)  // Slow network call
            let processedImage = self.applyFilters(photoData)  // CPU work
            
            // Update UI back on main thread
            DispatchQueue.main.async {
                self.imageView.image = processedImage
                self.hideLoadingSpinner()
            }
        }
    }
}
 
// Android/Kotlin approach
class PhotoViewModel : ViewModel() {
    fun loadPhoto(id: String) {
        viewModelScope.launch {
            _loadingState.value = LoadingState.Loading
            
            // withContext switches to background dispatcher
            val photo = withContext(Dispatchers.IO) {
                repository.downloadPhoto(id)  // Network I/O
            }
            
            val processed = withContext(Dispatchers.Default) {
                imageProcessor.apply(photo)  // CPU work
            }
            
            // Back on main dispatcher for UI update
            _photo.value = processed
            _loadingState.value = LoadingState.Success
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// Simplified game engine frame structure
class GameEngine {
    private threads = {
        main: new Thread(),       // Game logic, coordination
        render: new Thread(),     // GPU command submission
        physics: new Thread(),    // Physics simulation
        audio: new Thread(),      // Sound mixing and playback
        io: new ThreadPool(2),    // Asset streaming
        ai: new ThreadPool(4)     // NPC behavior, pathfinding
    };
    
    update() {
        // Frame N:
        // 1. Main thread dispatches work to other threads
        this.threads.physics.submit(() => this.simulatePhysics(this.deltaTime));
        this.threads.ai.submit(() => this.updateAI());
        
        // 2. While physics runs, main thread handles input
        this.processInput();
        
        // 3. Wait for physics (need results for rendering)
        this.threads.physics.await();
        
        // 4. Render thread builds GPU commands from game state
        this.threads.render.submit(() => this.buildRenderCommands());
        
        // 5. Main thread prepares next frame while GPU renders
        this.prepareNextFrame();
        
        // 6. Audio thread runs independently at 1000Hz+
        // (Never blocks or slows - audio glitches are unacceptable)
    }
}
 
// Frame timing budget (60fps):
// Total budget: 16.67ms
// Physics:      3ms (parallel with input)
// Input:        1ms
// Game logic:   4ms
// Render prep:  5ms
// GPU work:     10ms (overlaps with CPU on next frame)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

// Pattern 1: Parallel API aggregation
async function getProductPage(productId: string): Promise<ProductPage> {
    // Call multiple services in parallel
    const [product, reviews, inventory, recommendations] = await Promise.all([
        productService.getProduct(productId),        // 50ms
        reviewService.getReviews(productId),         // 80ms
        inventoryService.getStock(productId),        // 30ms
        recommendationService.getSimilar(productId)  // 100ms
    ]);
    
    // Total time: max(50, 80, 30, 100) = 100ms
    // Sequential would be: 50 + 80 + 30 + 100 = 260ms
    
    return { product, reviews, inventory, recommendations };
}
 
// Pattern 2: Saga pattern for distributed transactions
class OrderSaga {
    async execute(order: Order): Promise<void> {
        try {
            await paymentService.charge(order.payment);
            await inventoryService.reserve(order.items);
            await shippingService.schedule(order);
            await notificationService.confirm(order);
        } catch (error) {
            // Compensating transactions (saga rollback)
            await this.compensate(order, error.failedStep);
        }
    }
    
    async compensate(order: Order, failedAt: string): Promise<void> {
        switch (failedAt) {
            case 'shipping':
                await inventoryService.unreserve(order.items);
            case 'inventory':
                await paymentService.refund(order.payment);
        }
    }
}
 
// Pattern 3: Event-driven eventual consistency
class InventoryService {
    @EventHandler('OrderPlaced')
    async onOrderPlaced(event: OrderPlacedEvent) {
        // Reserve inventory asynchronously
        await this.reserveItems(event.orderId, event.items);
        
        // Publish event for downstream services
        await this.publish(new InventoryReservedEvent(event.orderId));
    }
    
    @EventHandler('OrderCancelled')
    async onOrderCancelled(event: OrderCancelledEvent) {
        // Release reservation
        await this.releaseItems(event.orderId);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// MapReduce pattern: embarrassingly parallel
// Example: Count word frequencies in a large corpus
 
// Map phase: Run on 1000 machines in parallel
function map(document: Document): KeyValuePair[] {
    return document.words.map(word => ({ key: word, value: 1 }));
}
 
// Shuffle phase: Group by key (framework handles)
// All pairs with same key go to same reducer
 
// Reduce phase: Aggregate counts
function reduce(key: string, values: number[]): KeyValuePair {
    return { key, value: values.reduce((a, b) => a + b, 0) };
}
 
// Result: Billions of documents processed in minutes
 
// Modern stream processing (Apache Kafka + Flink)
class RealTimeAnalytics {
    async processEventStream() {
        await kafka.stream('user-events')
            // Parallel processing across partitions
            .map(event => enrichWithUserData(event))
            
            // Window aggregation with parallelism
            .windowedBy(TumblingWindow.of(Duration.minutes(5)))
            .aggregate(countEvents)
            
            // Write results with exactly-once semantics
            .sink(clickhouseDatabase);
    }
}
 
// Processing scale:
// - 10 Kafka partitions = 10 parallel consumers minimum
// - Each consumer handles 10,000+ events/second
// - Scales horizontally by adding partitions and consumers

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# Training: Data parallelism across GPUs
model = DistributedDataParallel(
    model,
    device_ids=[0, 1, 2, 3]  # 4 GPUs in parallel
)
 
# Each GPU processes different batch, gradients synchronized
for batch in dataloader:
    loss = model(batch)
    loss.backward()  # Gradient sync happens automatically
 
# Inference: Concurrent request handling
class ModelServer:
    def __init__(self):
        self.model = load_model()
        self.batch_queue = asyncio.Queue()
        
    async def predict(self, input):
        # Add to batch, wait for result
        future = asyncio.Future()
        await self.batch_queue.put((input, future))
        return await future
        
    async def batch_processor(self):
        # Continuously batch and process
        while True:
            batch = await self.collect_batch()  # Max 32 items or 100ms
            predictions = self.model.predict(batch.inputs)
            for pred, future in zip(predictions, batch.futures):
                future.set_result(pred)
 
# Benefits: GPU efficiently utilized via batching
# Single inference: 10ms
# Batched (32): 15ms total = 0.47ms per item!