Swift concurrency async/await, Task, actor, અને @MainActor સાથે કેવી રીતે કામ કરે છે?

Question

IT Interview Practice · Accepted Answer

Swift concurrency તમને `async`/`await` વાપરીને એવો asynchronous code લખવા દે છે જે synchronous code જેવો વંચાય, જ્યારે compiler data-race safety ને enforce કરે છે. `Task` concurrent કામ શરૂ કરે છે, **actor** mutable state ને સુરક્ષિત રાખે છે, અને `@MainActor` ખાતરી કરે છે કે UI code main thread પર ચાલે.

## તે કેવી રીતે કામ કરે છે

`await` એ **suspension point** ને ચિહ્નિત કરે છે: function ત્યાં pause થઈ શકે છે, thread ને બીજા કામ માટે મુક્ત કરી, અને await કરેલી value તૈયાર થાય ત્યારે ફરી ચાલુ થાય — કોઈ callback નહીં, કોઈ thread blocking નહીં.

```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 અને @MainActor

**Actor** તેના mutable state ના access ને serialize કરે છે — એક સમયે માત્ર એક task તેને સ્પર્શે છે, તેથી કોઈ lock નહીં અને કોઈ data race નહીં.

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

## Structured concurrency

`async let` અને `TaskGroup` child ને parallel માં ચલાવે છે અને તેમને સાથે await કરે છે; parent ને cancel કરવાથી child પણ cancel થાય છે.

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

## મુશ્કેલીઓ

- UI update પર `@MainActor` ભૂલી જવાથી "Publishing changes from background thread" warning આવે છે.
- `Task { }` actor context inherit કરે છે; `Task.detached` નથી કરતું — તેને સંભાળીને વાપરો.

## આ શા માટે મહત્વનું છે

async/await એ ઊંડે nested completion handler ("callback hell") ને બદલ્યું અને compiler હવે build time પર data race પકડે છે. Interviewer ચકાસે છે કે તમે suspension point, actor isolation, અને `@MainActor` ને સમજો છો — એ model જે આધુનિક iOS concurrency ને વાંચી શકાય તેવું અને સુરક્ષિત બંને બનાવે છે.

તે કેવી રીતે કામ કરે છે

Actor અને @MainActor

Structured concurrency

મુશ્કેલીઓ

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો