iOS - Swift Concurrency

Modern concurrency patterns using async/await, actors, and structured concurrency in Swift.

Key Concepts

Async/Await Fundamentals

// Async function declaration func fetchUser(id: String) async throws -> User { let url = URL(string: "https://api.example.com/users/\(id)")! let (data, response) = try await URLSession.shared.data(from: url)

guard let httpResponse = response as? HTTPURLResponse,
      httpResponse.statusCode == 200 else {
    throw APIError.invalidResponse
}

return try JSONDecoder().decode(User.self, from: data)

}

// Calling async functions func loadUserProfile() async { do { let user = try await fetchUser(id: "123") await MainActor.run { updateUI(with: user) } } catch { await MainActor.run { showError(error) } } }

Task Management

class UserViewController: UIViewController { private var loadTask: Task<Void, Never>?

override func viewDidLoad() {
    super.viewDidLoad()

    // Create a task for async work
    loadTask = Task {
        await loadUserData()
    }
}

override func viewDidDisappear(_ animated: Bool) {
    super.viewDidDisappear(animated)
    // Cancel when view disappears
    loadTask?.cancel()
}

private func loadUserData() async {
    // Check for cancellation
    guard !Task.isCancelled else { return }

    do {
        let user = try await fetchUser()

        // Check again before UI update
        guard !Task.isCancelled else { return }

        await MainActor.run {
            displayUser(user)
        }
    } catch {
        // Handle error
    }
}

}

Actors for Thread Safety

actor UserCache { private var cache: [String: User] = [:]

func user(for id: String) -> User? {
    cache[id]
}

func setUser(_ user: User, for id: String) {
    cache[id] = user
}

func clear() {
    cache.removeAll()
}

}

// Usage let cache = UserCache()

Task { await cache.setUser(user, for: user.id) let cached = await cache.user(for: "123") }

MainActor for UI Updates

@MainActor class UserViewModel: ObservableObject { @Published var user: User? @Published var isLoading = false @Published var error: Error?

func loadUser(id: String) async {
    isLoading = true
    defer { isLoading = false }

    do {
        user = try await userService.fetchUser(id: id)
    } catch {
        self.error = error
    }
}

}

// Or use MainActor.run for specific operations func fetchAndDisplay() async { let data = await fetchData()

await MainActor.run {
    self.displayData(data)
}

}

Best Practices

Structured Concurrency with TaskGroup

func fetchAllUserData(userId: String) async throws -> UserProfile { async let user = fetchUser(id: userId) async let posts = fetchPosts(userId: userId) async let followers = fetchFollowers(userId: userId)

// All three requests run concurrently
return try await UserProfile(
    user: user,
    posts: posts,
    followers: followers
)

}

// For dynamic number of tasks func fetchMultipleUsers(ids: [String]) 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
}

}

AsyncSequence for Streams

// Custom async sequence struct NotificationStream: AsyncSequence { typealias Element = Notification

let name: Notification.Name

struct AsyncIterator: AsyncIteratorProtocol {
    let name: Notification.Name
    var iterator: AsyncStream<Notification>.Iterator

    mutating func next() async -> Notification? {
        await iterator.next()
    }
}

func makeAsyncIterator() -> AsyncIterator {
    let stream = AsyncStream<Notification> { continuation in
        let observer = NotificationCenter.default.addObserver(
            forName: name,
            object: nil,
            queue: nil
        ) { notification in
            continuation.yield(notification)
        }

        continuation.onTermination = { _ in
            NotificationCenter.default.removeObserver(observer)
        }
    }

    return AsyncIterator(name: name, iterator: stream.makeAsyncIterator())
}

}

// Usage for await notification in NotificationStream(name: .userDidLogin) { handleLogin(notification) }

Continuations for Callback-Based APIs

func fetchLegacyData() async throws -> Data { try await withCheckedThrowingContinuation { continuation in legacyAPI.fetch { result in switch result { case .success(let data): continuation.resume(returning: data) case .failure(let error): continuation.resume(throwing: error) } } } }

// For delegate-based APIs class LocationManager: NSObject, CLLocationManagerDelegate { private var locationContinuation: CheckedContinuation<CLLocation, Error>?

func getCurrentLocation() async throws -> CLLocation {
    try await withCheckedThrowingContinuation { continuation in
        self.locationContinuation = continuation
        locationManager.requestLocation()
    }
}

func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
    locationContinuation?.resume(returning: locations[0])
    locationContinuation = nil
}

func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
    locationContinuation?.resume(throwing: error)
    locationContinuation = nil
}

}

Common Patterns

Cancellation Handling

func downloadFile(url: URL) async throws -> Data { var data = Data()

let (bytes, _) = try await URLSession.shared.bytes(from: url)

for try await byte in bytes {
    // Cooperative cancellation check
    try Task.checkCancellation()
    data.append(byte)
}

return data

}

Debouncing with Task

class SearchViewModel: ObservableObject { @Published var searchText = "" @Published var results: [SearchResult] = []

private var searchTask: Task<Void, Never>?

func search(_ query: String) {
    searchTask?.cancel()

    searchTask = Task {
        // Debounce delay
        try? await Task.sleep(for: .milliseconds(300))

        guard !Task.isCancelled else { return }

        do {
            let results = try await searchService.search(query: query)
            guard !Task.isCancelled else { return }

            await MainActor.run {
                self.results = results
            }
        } catch {
            // Handle error
        }
    }
}

}

Combine Integration

import Combine

extension Publisher { func asyncMap<T>(_ transform: @escaping (Output) async -> T) -> AnyPublisher<T, Failure> { flatMap { value in Future { promise in Task { let result = await transform(value) promise(.success(result)) } } } .eraseToAnyPublisher() } }

// Convert async function to publisher func userPublisher(id: String) -> AnyPublisher<User, Error> { Future { promise in Task { do { let user = try await fetchUser(id: id) promise(.success(user)) } catch { promise(.failure(error)) } } } .eraseToAnyPublisher() }

Anti-Patterns

Blocking the Main Thread

Bad:

// DON'T do this func loadData() { let semaphore = DispatchSemaphore(value: 0) Task { data = await fetchData() semaphore.signal() } semaphore.wait() // Blocks main thread! }

Good:

func loadData() async { data = await fetchData() }

Ignoring Cancellation

Bad:

func processItems(_ items: [Item]) async { for item in items { await process(item) // Never checks cancellation } }

Good:

func processItems(_ items: [Item]) async throws { for item in items { try Task.checkCancellation() await process(item) } }

Data Races with Shared Mutable State

Bad:

class Counter { var count = 0 // Not thread-safe!

func increment() {
    count += 1
}

}

Good:

actor Counter { var count = 0

func increment() {
    count += 1
}

}

Related Skills

• ios-swiftui-patterns: Using concurrency with SwiftUI

• ios-uikit-architecture: Async patterns in UIKit