Swift concurrency lets you write asynchronous code that reads like synchronous code using async/await, while the compiler enforces data-race safety. Task starts concurrent work, actors protect mutable state, and @MainActor guarantees UI code runs on the main thread.
await marks a suspension point: the function can pause there, freeing the thread for other work, and resume when the awaited value is ready — no callbacks, no thread blocking.
func loadProfile() async throws -> Profile {
let user = try await fetchUser() // suspends, thread reused
let posts = try await fetchPosts(user) // runs after user resolves
return Profile(user: user, posts: posts)
}
// Start async work from a sync context
Task {
let profile = try await loadProfile()
await MainActor.run { render(profile) } // UI update on main thread
}
An actor serializes access to its mutable state — only one task touches it at a time, so no locks and no data races.
actor ImageCache {
private var store: [URL: Image] = [:]
func image(for url: URL) -> Image? { store[url] } // isolated
func insert(_ img: Image, for url: URL) { store[url] = img }
}
@MainActor
final class ViewModel: ObservableObject { // all members run on main thread
@Published var title = ""
}
async let and TaskGroup run children in parallel and await them together; cancelling the parent cancels the children.
async let a = fetchA() // both start immediately, in parallel
async let b = fetchB()
let (x, y) = try await (a, b)
@MainActor on UI updates causes "Publishing changes from background thread" warnings.Task { } inherits actor context; Task.detached does not — use it sparingly.async/await replaced deeply nested completion handlers ("callback hell") and the compiler now catches data races at build time. Interviewers check that you understand suspension points, actor isolation, and @MainActor — the model that makes modern iOS concurrency both readable and safe.
A library of IT interview questions with detailed answers — from Junior to Senior.
Donate