async/await, Task, actor-கள், மற்றும் @MainActor-உடன் Swift concurrency எப்படி வேலை செய்கிறது?

Question

IT Interview Practice · Accepted Answer

Swift concurrency, `async`/`await`-ஐப் பயன்படுத்தி synchronous code போல் படிக்கும் asynchronous code-ஐ எழுத உங்களை அனுமதிக்கிறது, அதே நேரத்தில் compiler data-race பாதுகாப்பை நடைமுறைப்படுத்துகிறது. `Task` concurrent வேலையைத் தொடங்குகிறது, **actor-கள்** mutable state-ஐப் பாதுகாக்கின்றன, மேலும் `@MainActor` UI code main thread-இல் இயங்குவதை உறுதிசெய்கிறது.

## இது எப்படி வேலை செய்கிறது

`await` ஒரு **suspension point**-ஐ குறிக்கிறது: function அங்கே pause ஆகி, மற்ற வேலைக்காக thread-ஐ விடுவித்து, await செய்யப்பட்ட value தயாராகும்போது resume ஆகும் — callback-கள் இல்லை, thread block ஆகுதல் இல்லை.

```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" எச்சரிக்கைகளை ஏற்படுத்துகிறது.
- `Task { }` actor context-ஐ inherit செய்கிறது; `Task.detached` செய்யவில்லை — அதை மிதமாகப் பயன்படுத்துங்கள்.

## இது ஏன் முக்கியம்

async/await ஆழமாக nested செய்யப்பட்ட completion handler-களை ("callback hell") மாற்றியது, மேலும் compiler இப்போது build நேரத்திலேயே data race-களைப் பிடிக்கிறது. suspension point-கள், actor isolation, மற்றும் `@MainActor`-ஐ நீங்கள் புரிந்துகொள்கிறீர்களா என்பதை interviewer-கள் சரிபார்க்கிறார்கள் — நவீன iOS concurrency-ஐ படிக்கக்கூடியதாகவும் பாதுகாப்பாகவும் ஆக்கும் model இதுவே.

இது எப்படி வேலை செய்கிறது

Actor-கள் மற்றும் @MainActor

Structured concurrency

சிக்கல்கள்

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்