Yaya Swift concurrency ke aiki da async/await, Task, actors, da @MainActor?

Question

IT Interview Practice · Accepted Answer

Swift concurrency yana ba ka damar rubuta asynchronous code da ke karantawa kamar synchronous code ta amfani da `async`/`await`, yayin da compiler ke tilasta data-race safety. `Task` yana fara concurrent work, **actors** suna kare mutable state, kuma `@MainActor` yana tabbatar UI code na gudana a main thread.

## Yadda yake aiki

`await` yana yiwa **suspension point** alama: function na iya dakatawa a nan, yana 'yantar da thread don wani aiki, sannan ya ci gaba lokacin da awaited value ya shirya — babu callbacks, babu toshe thread.

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

## Actors da @MainActor

**actor** yana serialize damar shiga mutable state ɗinsa — task ɗaya kawai ke taɓa shi a lokaci guda, don haka babu locks kuma babu data races.

```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` da `TaskGroup` suna gudanar da children a parallel kuma suna await su tare; soke parent yana soke children.

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

## Matsaloli

- Mantawa da `@MainActor` a kan UI updates yana haddasa gargaɗin "Publishing changes from background thread".
- `Task { }` yana gadar actor context; `Task.detached` ba ya gadarsa — yi amfani da shi da tsanaki.

## Me ya sa yake da muhimmanci

async/await ya maye gurbin zurfin nested completion handlers ("callback hell") kuma yanzu compiler ke kama data races a lokacin build. Masu tambayoyi suna duba ko ka fahimci suspension points, actor isolation, da `@MainActor` — model ɗin da ke sa concurrency na iOS na zamani duka mai sauƙin karantawa da aminci.

Yadda yake aiki

Actors da @MainActor

Structured concurrency

Matsaloli

Me ya sa yake da muhimmanci

Tambayoyi masu alaƙa