როგორ მუშაობს Swift concurrency async/await-ით, Task-ით, actor-ებითა და @MainActor-ით?

Question

IT Interview Practice · Accepted Answer

Swift concurrency საშუალებას გაძლევს დაწერო ასინქრონული კოდი, რომელიც სინქრონულივით იკითხება, `async`/`await`-ის გამოყენებით, ხოლო კომპილატორი უზრუნველყოფს data-race უსაფრთხოებას. `Task` იწყებს ერთდროულ სამუშაოს, **actor-ები** იცავენ ცვალებად მდგომარეობას, ხოლო `@MainActor` გარანტიას იძლევა, რომ UI კოდი main thread-ზე გაეშვება.

## როგორ მუშაობს

`await` აღნიშნავს **შეჩერების წერტილს**: ფუნქციას შეუძლია იქ დაპაუზდეს, გაათავისუფლოს thread სხვა სამუშაოსთვის და განაახლოს, როცა მოლოდინში მყოფი მნიშვნელობა მზადაა — callback-ების გარეშე, 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
}
```

## actor-ები და @MainActor

**actor** სერიალიზებას უკეთებს თავის ცვალებად მდგომარეობაზე წვდომას — მას ერთდროულად მხოლოდ ერთი 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` შვილებს პარალელურად უშვებენ და ერთად ელოდებიან; მშობლის გაუქმება შვილებსაც აუქმებს.

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

## ხაფანგები

- UI განახლებებზე `@MainActor`-ის დავიწყება იწვევს „Publishing changes from background thread“ გაფრთხილებებს.
- `Task { }` მემკვიდრეობით იღებს actor კონტექსტს; `Task.detached` — არა — გამოიყენე ის ზომიერად.

## რატომ არის ეს მნიშვნელოვანი

async/await-მა ჩაანაცვლა ღრმად ჩალაგებული completion handler-ები („callback hell“) და კომპილატორი ახლა build-ის დროს იჭერს data race-ებს. ინტერვიუერები ამოწმებენ, გესმის თუ არა შეჩერების წერტილები, actor-ის იზოლაცია და `@MainActor` — მოდელი, რომელიც თანამედროვე iOS concurrency-ს ხდის როგორც წაკითხვადს, ისე უსაფრთხოს.

როგორ მუშაობს

actor-ები და @MainActor

structured concurrency

ხაფანგები

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები