Hvordan fungerer Swift concurrency med async/await, Task, actors og @MainActor?

Question

IT Interview Practice · Accepted Answer

Swift concurrency lar deg skrive asynkron kode som leses som synkron kode ved hjelp av `async`/`await`, mens kompilatoren håndhever data-race-sikkerhet. `Task` starter samtidig arbeid, **actors** beskytter muterbar tilstand, og `@MainActor` garanterer at UI-kode kjører på hovedtråden.

## Slik fungerer det

`await` markerer et **suspensjonspunkt**: funksjonen kan pause der, frigjøre tråden til annet arbeid, og gjenoppta når den avventede verdien er klar — ingen callbacks, ingen trådblokkering.

```swift
func loadProfile() async throws -> Profile {
    let user  = try await fetchUser()       // suspenderer, tråden gjenbrukes
    let posts = try await fetchPosts(user)  // kjører etter at user er løst
    return Profile(user: user, posts: posts)
}

// Start asynkront arbeid fra en synkron kontekst
Task {
    let profile = try await loadProfile()
    await MainActor.run { render(profile) } // UI-oppdatering på hovedtråden
}
```

## Actors og @MainActor

En **actor** serialiserer tilgang til sin muterbare tilstand — bare én oppgave berører den om gangen, så ingen locks og ingen data races.

```swift
actor ImageCache {
    private var store: [URL: Image] = [:]
    func image(for url: URL) -> Image? { store[url] }   // isolert
    func insert(_ img: Image, for url: URL) { store[url] = img }
}

@MainActor
final class ViewModel: ObservableObject {   // alle medlemmer kjører på hovedtråden
    @Published var title = ""
}
```

## Strukturert concurrency

`async let` og `TaskGroup` kjører barn parallelt og avventer dem sammen; å kansellere forelderen kansellerer barna.

```swift
async let a = fetchA()      // begge starter umiddelbart, parallelt
async let b = fetchB()
let (x, y) = try await (a, b)
```

## Fallgruver

- Å glemme `@MainActor` på UI-oppdateringer forårsaker "Publishing changes from background thread"-advarsler.
- `Task { }` arver actor-kontekst; `Task.detached` gjør det ikke — bruk den sparsomt.

## Hvorfor det er viktig

async/await erstattet dypt nøstede completion handlers ("callback hell"), og kompilatoren fanger nå data races på byggetidspunktet. Intervjuere sjekker at du forstår suspensjonspunkter, actor-isolasjon og `@MainActor` — modellen som gjør moderne iOS-concurrency både lesbar og trygg.

Slik fungerer det

Actors og @MainActor

Strukturert concurrency

Fallgruver

Hvorfor det er viktig

Relaterte spørsmål