ax-concurrency-ref

Concurrency Profiling Reference

Quick Patterns

Swift Concurrency Instruments Template

Track	Information
Swift Tasks	Task lifetimes, parent-child relationships
Swift Actors	Actor access, contention visualization
Thread States	Blocked vs running vs suspended

Color Coding:

• Blue: Task executing
• Red: Task waiting (contention)
• Gray: Task suspended (awaiting)

Statistics:

• Running Tasks: Currently executing
• Alive Tasks: Present at a point in time
• Total Tasks: Cumulative count created

Cooperative Thread Pool Model

Aspect	GCD	Swift Concurrency
Threads	Grows unbounded	Fixed to core count
Blocking	Creates new threads	Suspends, frees thread
Dependencies	Hidden	Runtime-tracked
Context switch	Full kernel switch	Lightweight continuation

Decision Tree

Performance issue with async code?

├─ UI freezing
│   └─ Workflow 1: Main Thread Blocking
│
├─ Parallel work running sequentially
│   └─ Workflow 2: Actor Contention
│
├─ Tasks queued but not executing
│   └─ Workflow 3: Thread Pool Exhaustion
│
├─ High-priority work delayed
│   └─ Workflow 4: Priority Inversion
│
└─ Not sure where the bottleneck is
    └─ Start with Quick Checks, then profile

Deep Patterns

Workflow 1: Main Thread Blocking

Symptom: UI freezes, main thread timeline full

1. Profile with Swift Concurrency template
2. Look at main thread "Swift Tasks" lane
3. Find long blue bars (task executing on main)
4. Check if work could be offloaded

// WRONG: Heavy work on MainActor
@MainActor class ViewModel: ObservableObject {
    func process() {
        let result = heavyComputation()  // Blocks UI
        self.data = result
    }
}

// FIX: Offload heavy work
@MainActor class ViewModel: ObservableObject {
    func process() async {
        let result = await Task.detached {
            heavyComputation()
        }.value
        self.data = result
    }
}