Swift’s concurrency model introduces actors to provide safe, isolated access to mutable state. However, constantly using await when interacting with actors can create performance bottlenecks and reduce code readability. The isolated keyword offers an elegant solution by allowing synchronous access to actor state in specific contexts.

The Problem with Multiple Suspension Points

When working with actors, each interaction typically requires an await, creating suspension points that can impact performance:

actor Counter {
    private var value = 0
    
    func increment() { value += 1 }

    func decrement() { value -= 1 }

    func getValue() -> Int { value }
}

// Multiple suspension points
func performOperations(counter: Counter) async {

    await counter.increment()  // Suspension point 1

    await counter.increment()  // Suspension point 2

    await counter.decrement()  // Suspension point 3

    let result = await counter.getValue()  // Suspension point 4

    print("Final value: \(result)")
}

By marking a parameter as isolated, you can eliminate suspension points and gain synchronous access to that specific actor:

// Optimized version with isolated parameter
func performOperations(counter: isolated Counter) async {

    counter.increment()  // No await needed

    counter.increment()  // No await needed

    counter.decrement()  // No await needed

    let result = counter.getValue()  // No await needed

    print("Final value: \(result)")
}

// The function is still async, so you need await when calling it
await performOperations(counter: myCounter)

Tip: The isolated parameter approach brings several compelling advantages to your Swift concurrency code. Most notably, it dramatically reduces the number of suspension points within your function, which means fewer interruptions in execution flow. This reduction translates directly into improved performance since your code experiences fewer context switches between different execution contexts.**

Beyond performance gains, isolated parameters make your code significantly more readable. Instead of scattering await keywords throughout your function calls, you can write code that flows more naturally and resembles synchronous programming. This cleaner syntax makes it easier for developers to understand the logic without getting distracted by concurrency mechanics.

Isolated Closures: Atomic Block Execution

Isolated closures take the concept further by executing entire code blocks within an actor’s context:

struct BatchProcessor {
    static func performBatchOperations(counter: Counter) async {
        await withTaskGroup(of: Void.self) { group in
            for i in 1...5 {
                group.addTask { @isolated(counter) in
                    // All operations are atomic within this closure
                    counter.increment()

                    counter.increment()

                    counter.decrement()

                    let current = counter.getValue()

                    print("Task \(i): \(current)")
                }
            }
        }
    }
}