A Complete Guide to Swift Concurrency in SwiftUI

Swift Concurrency, introduced in Swift 5.5 and continuously enhanced in later versions (including Swift 5.9), has redefined how iOS developers write asynchronous code. With features like async/await, Task, TaskGroup, MainActor, and Actors, Swift now provides a modern, safe, and readable approach to concurrency. In this guide, we’ll explore these concepts within the context of a SwiftUI application.

Why Concurrency Matters in SwiftUI

In SwiftUI, user interfaces must stay responsive. Time-consuming operations like API calls, file I/O, or complex calculations should not block the main thread. Swift Concurrency allows developers to perform these tasks in the background and update the UI seamlessly on the main thread, improving both performance and user experience.

Async/Await: Writing Cleaner Async Code

Before Swift Concurrency, developers relied on completion handlers, which led to nested, hard-to-read code. Now, async/await lets us write asynchronous code that looks and feels like synchronous logic.

func fetchUserProfile() async throws -> String {
    try await Task.sleep(nanoseconds: 1_000_000_000)
    return "User profile loaded."
}

func loadProfile() {
    Task {
        do {
            let profile = try await fetchUserProfile()
            print("✅ Profile: \(profile)")
        } catch {
            print("❌ Error loading profile: \(error.localizedDescription)")
        }
    }
}

Structured Concurrency: Running Tasks Together

With async let, we can run multiple asynchronous functions concurrently, then await their results together. This makes parallel tasks much simpler and safer.

func fetchUserProfileAndSettings() async throws {
    async let profile = fetchUserProfile()
    async let settings = fetchUserSettings()
    let (user, preferences) = try await (profile, settings)
    print("User: \(user), Settings: \(preferences)")
}

func fetchUserSettings() async throws -> String {
    try await Task.sleep(nanoseconds: 500_000_000)
    return "Dark mode: ON"
}

SwiftUI + MainActor: Safely Updating the UI

SwiftUI views must be updated on the main thread. To ensure safety, use @MainActor to isolate updates to your UI-related code.

@MainActor
class UserViewModel: ObservableObject {
    @Published var username: String = ""

    func loadUserName() async {
        let name = await fetchUserName()
        username = name
    }
}

func fetchUserName() async -> String {
    try? await Task.sleep(nanoseconds: 1_000_000_000)
    return "John Appleseed"
}

And use it in a SwiftUI view like this:

struct ContentView: View {
    @StateObject private var viewModel = UserViewModel()

    var body: some View {
        VStack {
            Text("Welcome, \(viewModel.username)")
                .padding()
            Button("Load Username") {
                Task {
                    await viewModel.loadUserName()
                }
            }
        }
    }
}

Using TaskGroup for Dynamic Concurrency

TaskGroup is ideal when you need to launch an unknown number of tasks in parallel and gather their results.

func fetchMultipleResources() async {
    await withTaskGroup(of: String.self) { group in
        for id in 1...3 {
            group.addTask {
                try? await Task.sleep(nanoseconds: UInt64(id) * 300_000_000)
                return "Fetched item \(id)"
            }
        }

        for await result in group {
            print("🔹 \(result)")
        }
    }
}

Actors: Safe State Sharing Across Tasks

actor is Swift's solution to safely mutate shared state across concurrent tasks.

actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        value
    }
}

func demoActor() async {
    let counter = Counter()
    await counter.increment()
    let currentValue = await counter.getValue()
    print("🔢 Counter value: \(currentValue)")
}

Continuations: Bridging Legacy APIs

withCheckedContinuation lets you integrate older completion handler-based APIs into Swift Concurrency.

func legacyAPICall(completion: @escaping (String) -> Void) {
    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
        completion("Legacy API Result")
    }
}

func useWithContinuation() async -> String {
    await withCheckedContinuation { continuation in
        legacyAPICall { result in
            continuation.resume(returning: result)
        }
    }
}

Best Practices

• Use @MainActor for ViewModels that update SwiftUI views.
• Avoid unstructured concurrency unless necessary. Use Task {} responsibly.
• Leverage async let and TaskGroup for concurrent work.
• Use actor to manage shared mutable state safely.
• Integrate legacy APIs with continuations, but prefer modern async APIs when available.

Conclusion

Swift Concurrency has dramatically improved the way developers build responsive and safe iOS apps. By understanding and applying async/await, structured concurrency, MainActor, TaskGroup, and actor, you can write cleaner, safer, and more scalable SwiftUI apps.

Take time to experiment with these tools, refactor older code, and build habits around writing modern asynchronous logic.