swift concurrency

Swift Concurrency

Introduction

Swift's modern concurrency model provides structured, safe concurrent programming through async/await syntax, actors for data isolation, and task management primitives. This system eliminates common concurrency bugs like data races and callback hell while improving code readability and maintainability.

Introduced in Swift 5.5, the concurrency model integrates with the language's type system to enforce safety at compile time. Actors protect mutable state, async/await makes asynchronous code look synchronous, and structured concurrency ensures tasks are properly managed and cancelled.

This skill covers async functions, actors, task groups, cancellation, async sequences, and patterns for migrating from completion handlers to modern concurrency.

Async/Await Fundamentals

Async/await syntax enables writing asynchronous code that reads like synchronous code, without nested callbacks or complex error handling chains.

// Basic async function func fetchUser(id: Int) async throws -> User { let url = URL(string: "https://api.example.com/users/\(id)")! let (data, _) = try await URLSession.shared.data(from: url) return try JSONDecoder().decode(User.self, from: data) }

// Calling async functions func loadUserProfile() async { do { let user = try await fetchUser(id: 42) print("Loaded user: (user.name)") } catch { print("Failed to load user: (error)") } }

// Sequential async calls func loadFullProfile() async throws -> Profile { let user = try await fetchUser(id: 42) let posts = try await fetchPosts(userId: user.id) let comments = try await fetchComments(userId: user.id)

return Profile(user: user, posts: posts, comments: comments)

}

// Parallel async calls with async let func loadProfileParallel() async throws -> Profile { async let user = fetchUser(id: 42) async let posts = fetchPosts(userId: 42) async let comments = fetchComments(userId: 42)

return try await Profile(
    user: user,
    posts: posts,
    comments: comments
)

}

// Async properties struct UserRepository { var currentUser: User { get async throws { return try await fetchUser(id: getCurrentUserId()) } } }

// Using async properties func displayUser(repo: UserRepository) async { do { let user = try await repo.currentUser print(user.name) } catch { print("Error: (error)") } }

// Async initializers class DataManager { let data: Data

init() async throws {
    let url = URL(string: "https://api.example.com/config")!
    let (data, _) = try await URLSession.shared.data(from: url)
    self.data = data
}

}

Async functions suspend execution at await points, allowing other work to proceed without blocking threads. The runtime manages suspension and resumption efficiently.

Actors for Safe Concurrency

Actors protect mutable state from concurrent access, preventing data races by ensuring only one task can access actor-isolated state at a time.

// Basic actor actor Counter { private var value = 0

func increment() {
    value += 1
}

func getValue() -> Int {
    return value
}

}

// Using actors func useCounter() async { let counter = Counter()

await counter.increment()
let value = await counter.getValue()
print("Counter: \(value)")

}

// Actor with async methods actor ImageCache { private var cache: [URL: Image] = [:]

func image(for url: URL) async throws -> Image {
    if let cached = cache[url] {
        return cached
    }

    let (data, _) = try await URLSession.shared.data(from: url)
    guard let image = Image(data: data) else {
        throw ImageError.invalidData
    }

    cache[url] = image
    return image
}

func clear() {
    cache.removeAll()
}

}

enum ImageError: Error { case invalidData }

struct Image { init?(data: Data) { // Initialize image return nil } }

// MainActor for UI updates @MainActor class ViewModel: ObservableObject { @Published var users: [User] = []

func loadUsers() async {
    do {
        let fetchedUsers = try await fetchAllUsers()
        users = fetchedUsers // Safe: on main actor
    } catch {
        print("Failed to load users: \(error)")
    }
}

}

func fetchAllUsers() async throws -> [User] { return [] }

// Nonisolated methods actor DatabaseManager { private var connection: Connection?

nonisolated func formatQuery(_ query: String) -> String {
    // Doesn't access actor state, no await needed
    return query.trimmingCharacters(in: .whitespaces)
}

func execute(_ query: String) async throws {
    // Accesses actor state
    guard let connection = connection else {
        throw DatabaseError.notConnected
    }
    // Execute query
}

}

struct Connection {} enum DatabaseError: Error { case notConnected }

// Global actor for custom isolation @globalActor actor DatabaseActor { static let shared = DatabaseActor() }

@DatabaseActor class QueryBuilder { var table: String = ""

func buildQuery() -> String {
    return "SELECT * FROM \(table)"
}

}

Actors automatically serialize access to their state, eliminating data races while maintaining code clarity and avoiding manual lock management.

Structured Concurrency with Task Groups

Task groups enable spawning multiple concurrent tasks with automatic lifecycle management and result collection.

// Basic task group func fetchMultipleUsers(ids: [Int]) async throws -> [User] { try await withThrowingTaskGroup(of: User.self) { group in for id in ids { group.addTask { try await fetchUser(id: id) } }

    var users: [User] = []
    for try await user in group {
        users.append(user)
    }
    return users
}

}

// Non-throwing task group func loadImages(urls: [URL]) async -> [Image] { await withTaskGroup(of: Image?.self) { group in for url in urls { group.addTask { try? await downloadImage(from: url) } }

    var images: [Image] = []
    for await image in group {
        if let image = image {
            images.append(image)
        }
    }
    return images
}

}

func downloadImage(from url: URL) async throws -> Image { let (data, _) = try await URLSession.shared.data(from: url) guard let image = Image(data: data) else { throw ImageError.invalidData } return image }

// Limited concurrency with task groups func processItems<T>( _ items: [T], maxConcurrent: Int, process: @escaping (T) async throws -> Void ) async throws { try await withThrowingTaskGroup(of: Void.self) { group in var index = 0

    // Start initial batch
    for _ in 0..&#x3C;min(maxConcurrent, items.count) {
        let item = items[index]
        group.addTask {
            try await process(item)
        }
        index += 1
    }

    // Process remaining items
    while index &#x3C; items.count {
        try await group.next()
        let item = items[index]
        group.addTask {
            try await process(item)
        }
        index += 1
    }

    // Wait for remaining tasks
    try await group.waitForAll()
}

}

// Task group with results dictionary func fetchUserData(userIds: [Int]) async throws -> [Int: UserData] { try await withThrowingTaskGroup( of: (Int, UserData).self ) { group in for id in userIds { group.addTask { let data = try await loadUserData(id: id) return (id, data) } }

    var results: [Int: UserData] = [:]
    for try await (id, data) in group {
        results[id] = data
    }
    return results
}

}

struct UserData {}

func loadUserData(id: Int) async throws -> UserData { return UserData() }

// Early termination func findFirstMatch(items: [String]) async -> String? { await withTaskGroup(of: String?.self) { group in for item in items { group.addTask { await checkMatch(item) } }

    for await result in group {
        if let match = result {
            group.cancelAll()
            return match
        }
    }
    return nil
}

}

func checkMatch(_ item: String) async -> String? { // Simulate async work return item.count > 5 ? item : nil }

Task groups provide structured concurrency: all child tasks complete or are cancelled before the group exits, preventing task leaks.

Task Management and Cancellation

Tasks represent units of asynchronous work with lifecycle management, cancellation support, and priority configuration.

// Creating detached tasks func backgroundUpdate() { Task.detached(priority: .background) { await performHeavyComputation() } }

func performHeavyComputation() async { // Heavy work }

// Storing and cancelling tasks class DataLoader { private var loadTask: Task<Data, Error>?

func startLoading() {
    loadTask = Task {
        try await loadData()
    }
}

func cancelLoading() {
    loadTask?.cancel()
    loadTask = nil
}

func loadData() async throws -> Data {
    let url = URL(string: "https://api.example.com/data")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

}

// Checking for cancellation func processLargeDataset(items: [Item]) async throws { for item in items { try Task.checkCancellation() await process(item) } }

struct Item {}

func process(_ item: Item) async { // Process item }

// Cooperative cancellation func downloadWithProgress(url: URL) async throws -> Data { let (bytes, response) = try await URLSession.shared.bytes(from: url)

var data = Data()
for try await byte in bytes {
    if Task.isCancelled {
        throw CancellationError()
    }
    data.append(byte)
}

return data

}

// Task priorities enum TaskPriority { case high, medium, low

var priority: TaskPriority {
    switch self {
    case .high: return .high
    case .medium: return .medium
    case .low: return .low
    }
}

}

func scheduleTask(priority: TaskPriority, work: @escaping () async -> Void) { Task(priority: priority.priority) { await work() } }

// Task values and results func loadUserAsync() async throws -> User { let task = Task<User, Error> { try await fetchUser(id: 1) }

return try await task.value

}

// Unstructured tasks with context @MainActor class ViewController { func loadData() { Task { @MainActor in let data = try await fetchData() updateUI(with: data) } }

func fetchData() async throws -> Data {
    return Data()
}

func updateUI(with data: Data) {
    // Update UI
}

}

Tasks automatically inherit priority, task-local values, and actor context from their creation site, ensuring proper execution environment.

Async Sequences

Async sequences provide asynchronous iteration over values that arrive over time, enabling clean handling of streams, events, and paginated data.

// Basic async sequence struct AsyncCountdown: AsyncSequence { typealias Element = Int

let start: Int

struct AsyncIterator: AsyncIteratorProtocol {
    var current: Int

    mutating func next() async -> Int? {
        guard current >= 0 else { return nil }
        let value = current
        current -= 1
        try? await Task.sleep(nanoseconds: 1_000_000_000)
        return value
    }
}

func makeAsyncIterator() -> AsyncIterator {
    return AsyncIterator(current: start)
}

}

// Using async sequences func countDown() async { let countdown = AsyncCountdown(start: 5) for await number in countdown { print(number) } }

// Async sequence operations func processStream(urls: [URL]) async throws { let (bytes, _) = try await URLSession.shared.bytes( from: urls[0] )

for try await byte in bytes {
    processByte(byte)
}

}

func processByte(_ byte: UInt8) { // Process byte }

// AsyncStream for custom sequences func temperatures() -> AsyncStream<Double> { AsyncStream { continuation in let sensor = TemperatureSensor() sensor.onReading = { temperature in continuation.yield(temperature) }

    continuation.onTermination = { _ in
        sensor.stop()
    }

    sensor.start()
}

}

class TemperatureSensor { var onReading: ((Double) -> Void)?

func start() {}
func stop() {}

}

// Using AsyncStream func monitorTemperature() async { for await temp in temperatures() { print("Temperature: (temp)°C") if temp > 100 { break } } }

// Transforming async sequences func filteredTemperatures() async { let temps = temperatures() for await temp in temps where temp > 0 { print("Positive temperature: (temp)") } }

// AsyncThrowingStream for errors func networkEvents() -> AsyncThrowingStream<NetworkEvent, Error> { AsyncThrowingStream { continuation in let monitor = NetworkMonitor()

    monitor.onEvent = { event in
        continuation.yield(event)
    }

    monitor.onError = { error in
        continuation.finish(throwing: error)
    }

    monitor.start()
}

}

struct NetworkEvent {}

class NetworkMonitor { var onEvent: ((NetworkEvent) -> Void)? var onError: ((Error) -> Void)?

func start() {}

}

Async sequences integrate with for-await-in loops and support transformation, filtering, and composition like synchronous sequences.

Best Practices

Use async/await instead of completion handlers to improve readability and avoid callback pyramids in new code

Protect mutable state with actors rather than manual locks to prevent data races with compile-time guarantees

Prefer structured concurrency with task groups over detached tasks to ensure proper lifecycle management and cancellation

Check Task.isCancelled in long-running operations to enable cooperative cancellation and resource cleanup

Use MainActor for UI code to ensure UI updates happen on the main thread without explicit dispatch calls

Leverage async let for parallel execution when multiple independent async operations can run concurrently

Employ async sequences for streams instead of callbacks or delegates when handling values that arrive over time

Mark nonisolated methods appropriately on actors when they don't access isolated state to avoid unnecessary awaits

Set task priorities explicitly for background work to prevent priority inversion and ensure responsive UI

Use withTaskCancellationHandler to clean up resources immediately when tasks are cancelled rather than waiting for checkpoints

Common Pitfalls

Blocking main thread with await in synchronous contexts causes hangs; create Task wrappers to bridge to async code

Not checking for cancellation in long operations wastes resources and delays response to user actions

Creating retain cycles with unowned/weak incorrectly in async closures can cause crashes or memory leaks

Mixing async/await with completion handlers improperly creates race conditions and difficult-to-debug behavior

Overusing detached tasks loses structured concurrency benefits like automatic cancellation and priority inheritance

Forgetting await on actor methods causes compilation errors since actor isolation requires suspension points

Not using throwing variants of task APIs when errors are possible leads to silent failures and unhandled errors

Accessing actor state without isolation by making properties public defeats the purpose of actor protection

Creating too many concurrent tasks without limits exhausts system resources and degrades performance

Assuming immediate execution after await; other tasks may run before continuation, breaking assumptions about state

When to Use This Skill

Use Swift concurrency when building iOS 15+, macOS 12+, watchOS 8+, or tvOS 15+ applications that perform asynchronous operations like networking, file I/O, or background processing.

Apply async/await when working with URLSession, Core Data async methods, or any API that supports modern concurrency instead of completion handlers.

Employ actors when managing shared mutable state accessed from multiple concurrent contexts, especially in data managers, caches, or repositories.

Leverage task groups when performing multiple independent async operations that should be coordinated, like fetching data for multiple users or processing a batch of items concurrently.

Use async sequences when handling streams of data from sensors, network connections, file reading, or any source that produces values over time.

Resources

Swift Concurrency Documentation
Meet async/await WWDC Session
Protect Mutable State with Swift Actors
Swift Evolution - Concurrency Proposals
Swift Concurrency Roadmap

swift concurrency

Safety Notice

Copy this and send it to your AI assistant to learn

Source Transparency

Related Skills

typescript-type-system

typescript-async-patterns

c-systems-programming

cpp-templates-metaprogramming