async/await, Task, actors, आणि @MainActor सह Swift concurrency कसे कार्य करते?

Question

IT Interview Practice · Accepted Answer

Swift concurrency तुम्हाला `async`/`await` वापरून synchronous code सारखा वाचणारा asynchronous code लिहू देते, तर compiler data-race safety लागू करतो. `Task` concurrent काम सुरू करते, **actors** mutable state चे रक्षण करतात, आणि `@MainActor` हमी देते की UI code main thread वर चालेल.

## हे कसे कार्य करते

`await` एक **suspension point** चिन्हांकित करते: function तिथे थांबू शकते, thread ला इतर कामासाठी मोकळा करते, आणि awaited मूल्य तयार झाल्यावर पुन्हा सुरू होते — callbacks नाहीत, 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
}
```

## Actors आणि @MainActor

एक **actor** आपल्या mutable state वरील access serialize करते — एका वेळी फक्त एकच task त्याला स्पर्श करते, त्यामुळे locks नाहीत आणि 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` आणि `TaskGroup` children ना parallel मध्ये चालवतात आणि त्यांना एकत्र await करतात; parent cancel केल्यास children cancel होतात.

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

## अडचणी

- UI updates वर `@MainActor` विसरल्याने "Publishing changes from background thread" warnings येतात.
- `Task { }` actor context inherit करते; `Task.detached` करत नाही — तो जपून वापरा.

## हे का महत्त्वाचे आहे

async/await ने खोलवर nested completion handlers ("callback hell") ची जागा घेतली आणि आता compiler build time लाच data races पकडतो. मुलाखतकार तपासतात की तुम्हाला suspension points, actor isolation, आणि `@MainActor` समजते का — तेच model आधुनिक iOS concurrency ला वाचनीय आणि सुरक्षित बनवते.

हे कसे कार्य करते

Actors आणि @MainActor

Structured concurrency

अडचणी

हे का महत्त्वाचे आहे

संबंधित प्रश्न