Benchmarking iOS Synchronization: Methodology and Results

Benchmarking synchronization primitives is tricky. Here's a methodology that produces meaningful results—and what we found on real devices.

Follow along with the code: iOS-Practice on GitHub

Benchmarking Methodology

Good benchmarks need:

1. Warmup - JIT compilation, cache warming, thread pool initialization
2. Multiple iterations - We run 3x and take the median to reduce noise
3. Realistic scenarios - Different workloads reveal different characteristics

Test Scenarios

We tested five workload patterns at 50,000 operations each:

The Results

Testing on device with NSLock, os_unfair_lock, OSAllocatedUnfairLock, and Actor:

Balanced (50/50 read/write):

Actor is 2.8x faster than the fastest lock under balanced concurrent load.

Read Heavy (90% reads):

Actor is 2.7x faster. All locks perform similarly.

Write Heavy (90% writes):

Actor is 2.7x faster. Similar pattern to read-heavy.

Heavy Work Inside Lock:

Actor is 7.5x faster. Long lock hold times amplify thread contention.

Serial (No Concurrency):

os_unfair_lock is 39x faster than Actor in serial code.

Why Actors Win Under Concurrency

When you dispatch 50,000 operations to a concurrent queue with locks:

let queue = DispatchQueue(label: "test", attributes: .concurrent)
for i in 0..<50_000 {
    queue.async {
        container.write(i)  // Lock contention!
    }
}

GCD spawns threads—lots of them. They all contend for the same lock, burning CPU on context switches and spin-waiting.

Actors use cooperative scheduling:

await withTaskGroup(of: Void.self) { group in
    for i in 0..<50_000 {
        group.addTask {
            await container.write(i)
        }
    }
}

The Swift runtime limits thread count and manages suspension efficiently. Less contention, more throughput.

Why Locks Win in Serial Code

Without concurrency, locks are just function calls—a few assembly instructions. Actors require task suspension, executor scheduling, and potential context switches. That overhead dominates when there's no contention.

Interview Tip

"I've benchmarked these primitives on device. Actors are 2.5-3x faster under concurrency, and up to 7x faster with heavy work inside the critical section. But in serial code, locks are 39x faster—no async overhead. I profile before choosing."