Jak działa współbieżność w Swift z async/await, Task, aktorami i @MainActor?

Question

IT Interview Practice · Accepted Answer

Współbieżność w Swift pozwala pisać kod asynchroniczny, który czyta się jak synchroniczny, używając `async`/`await`, podczas gdy kompilator wymusza bezpieczeństwo przed wyścigami danych (data races). `Task` uruchamia współbieżną pracę, **aktorzy** (actors) chronią stan mutowalny, a `@MainActor` gwarantuje, że kod UI działa na głównym wątku.

## Jak to działa

`await` oznacza **punkt zawieszenia** (suspension point): funkcja może się tam wstrzymać, zwalniając wątek dla innej pracy, i wznowić, gdy oczekiwana wartość jest gotowa — bez callbacków, bez blokowania wątku.

```swift
func loadProfile() async throws -> Profile {
    let user  = try await fetchUser()       // zawiesza, wątek reużyty
    let posts = try await fetchPosts(user)  // działa po rozwiązaniu user
    return Profile(user: user, posts: posts)
}

// Uruchom pracę async z kontekstu synchronicznego
Task {
    let profile = try await loadProfile()
    await MainActor.run { render(profile) } // aktualizacja UI na głównym wątku
}
```

## Aktorzy i @MainActor

**Aktor** serializuje dostęp do swojego mutowalnego stanu — tylko jedno zadanie dotyka go naraz, więc bez blokad i bez wyścigów danych.

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

@MainActor
final class ViewModel: ObservableObject {   // wszystkie składowe działają na głównym wątku
    @Published var title = ""
}
```

## Współbieżność strukturalna

`async let` i `TaskGroup` uruchamiają dzieci równolegle i czekają na nie razem; anulowanie rodzica anuluje dzieci.

```swift
async let a = fetchA()      // oba startują natychmiast, równolegle
async let b = fetchB()
let (x, y) = try await (a, b)
```

## Pułapki

- Zapomnienie o `@MainActor` przy aktualizacjach UI powoduje ostrzeżenia "Publishing changes from background thread".
- `Task { }` dziedziczy kontekst aktora; `Task.detached` nie — używaj go oszczędnie.

## Dlaczego to ważne

async/await zastąpiło głęboko zagnieżdżone completion handlers ("callback hell"), a kompilator wychwytuje teraz wyścigi danych podczas budowania. Rekruterzy sprawdzają, czy rozumiesz punkty zawieszenia, izolację aktorów i `@MainActor` — model, który czyni nowoczesną współbieżność iOS zarazem czytelną i bezpieczną.

Jak to działa

Aktorzy i @MainActor

Współbieżność strukturalna

Pułapki

Dlaczego to ważne

Powiązane pytania