Hogyan működik a Swift concurrency az async/await, Task, actorök és @MainActor segítségével?

Question

IT Interview Practice · Accepted Answer

A Swift concurrency lehetővé teszi, hogy olyan aszinkron kódot írj, amely szinkron kódként olvasható, az `async`/`await` segítségével, miközben a fordító kikényszeríti az adatverseny-biztonságot. A `Task` konkurens munkát indít, az **actorök** megvédik a módosítható állapotot, a `@MainActor` pedig garantálja, hogy a UI-kód a fő szálon fut.

## Hogyan működik

Az `await` egy **felfüggesztési pontot** jelöl: a függvény ott szünetelhet, felszabadítva a szálat más munkára, és folytatódik, amikor a várt érték elkészül — nincsenek callbackek, nincs szálblokkolás.

```swift
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
}
```

## Actorök és @MainActor

Egy **actor** sorosítja a hozzáférést a módosítható állapotához — egyszerre csak egy task érinti, így nincsenek zárak és adatversenyek.

```swift
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 = ""
}
```

## Strukturált konkurencia

Az `async let` és a `TaskGroup` párhuzamosan futtatja a gyerekeket, és együtt várja meg őket; a szülő megszakítása megszakítja a gyerekeket is.

```swift
async let a = fetchA()      // both start immediately, in parallel
async let b = fetchB()
let (x, y) = try await (a, b)
```

## Buktatók

- Ha megfeledkezel a `@MainActor`-ról a UI-frissítéseknél, az „Publishing changes from background thread” figyelmeztetéseket okoz.
- A `Task { }` örökli az actor kontextusát; a `Task.detached` nem — takarékosan használd.

## Miért fontos

Az async/await leváltotta a mélyen egymásba ágyazott completion handlereket („callback hell”), és a fordító most már fordítási időben elkapja az adatversenyeket. Az interjúztatók azt ellenőrzik, hogy érted-e a felfüggesztési pontokat, az actor-izolációt és a `@MainActor`-t — azt a modellt, amely a modern iOS-konkurenciát egyszerre olvashatóvá és biztonságossá teszi.

Hogyan működik

Actorök és @MainActor

Strukturált konkurencia

Buktatók

Miért fontos

Kapcsolódó kérdések