Swift concurrency async/await, Task, actor లు, మరియు @MainActor తో ఎలా పనిచేస్తుంది?

Question

IT Interview Practice · Accepted Answer

Swift concurrency `async`/`await` ను వాడి synchronous code లా చదవగలిగే asynchronous code ను వ్రాయనిస్తుంది, అదే సమయంలో compiler data-race safety ను అమలు చేస్తుంది. `Task` concurrent పనిని ప్రారంభిస్తుంది, **actor లు** mutable state ను రక్షిస్తాయి, మరియు `@MainActor` UI code main thread లో run అవుతుందని హామీ ఇస్తుంది.

## ఇది ఎలా పనిచేస్తుంది

`await` ఒక **suspension point** ను గుర్తిస్తుంది: function అక్కడ pause అవగలదు, ఇతర పని కోసం thread ను విడుదల చేస్తుంది, మరియు await చేసిన విలువ సిద్ధమైనప్పుడు resume అవుతుంది — 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 మాత్రమే దాన్ని touch చేస్తుంది, కాబట్టి 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 గా run చేసి వాటిని కలిసి 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" హెచ్చరికలకు కారణమవుతుంది.
- `Task { }` actor context ను inherit చేస్తుంది; `Task.detached` చేయదు — దాన్ని పొదుపుగా వాడండి.

## ఇది ఎందుకు ముఖ్యం

async/await లోతుగా nested అయిన completion handler లను ("callback hell") భర్తీ చేసింది మరియు compiler ఇప్పుడు build time లో data race లను పట్టుకుంటుంది. మీరు suspension point లు, actor isolation, మరియు `@MainActor` ను అర్థం చేసుకున్నారా అని interviewer లు తనిఖీ చేస్తారు — ఆధునిక iOS concurrency ను చదవగలిగేదిగా మరియు సురక్షితంగా చేసే model.

ఇది ఎలా పనిచేస్తుంది

Actor లు మరియు @MainActor

Structured concurrency

లోపాలు

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు