Miks ei soovitata iOS-is peamist niiti koormata ja…

Peatüki vastutab kasutajaliidese uuendamise ja UI sündmuste töötlemise eest. Kõik pikemaajalised toimingud (võrgu päringud, rasked arvutused, failidega töötamine) peamise lõngaga blokeerivad selle, mis põhjustab UI "külmumist", madalat reageerimisvõimet ja isegi rakenduse krahhi (watchdog timeout).

Kuidas vältida koormust peamisele lõngale:

Grand Central Dispatch (GCD): võimaldab täita ülesandeid asünkroonselt taustajärjestustes.
- DispatchQueue.global(): saadakse globaalne taustajärjestus erineva prioriteediga.
- DispatchQueue.main: peamine järjekord UI uuendamiseks.
- async { ... }: koodi ploki täitmine asünkroonselt.
```
// raske ülesande täitmine taustal
DispatchQueue.global(qos: .userInitiated).async {
    // rasked arvutused või võrgupäring

    // UI uuendamine peamisel lõngal
    DispatchQueue.main.async {
        // kasutajaliidese uuendamine
    }
}
```

Operation Queue (Operation & OperationQueue): kõrgema taseme abstraktsioon Dispatch Queue-dele, mis toetab sõltuvusi operatsioonide vahel, tühistamist ja peatamist.

OperationQueue(): operatsioonijärjestuse loomine.
Operation: abstraktne klass ülesannete jaoks, mida saab järjekorda lisada.
addOperation(_:): operatsiooni lisamine järjekorda.

let downloadOperation = BlockOperation {
    // andmete allalaadimine
}

let parseOperation = BlockOperation {
    // andmete analüüs
}

// sõltuvus: analüüs algab pärast allalaadimist
parseOperation.addDependency(downloadOperation)

let queue = OperationQueue()
queue.addOperation(downloadOperation)
queue.addOperation(parseOperation)

Concurrency (async/await): kaasaegne lähenemisviis Swiftis asünkroonseks programmeerimiseks.

async: märgib funktsiooni kui asünkroonset.
await: ootab asünkroonse operatsiooni lõpetamist.
Task: loob uue konkurentsivõimelise ülesande.

func fetchData() async throws -> Data {
    let url = URL(string: "https://example.com/data")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

func updateUI() {
    Task {
        do {
            let data = try await fetchData()
            // andmete töötlemine
            // UI uuendamine peamisel lõngal automaatselt
            // (kui ülesanne luuakse peamise aktori või DispatchQueue.main-ga)
        } catch {
            // vea töötlemine
        }
    }
}

Actors: ennetavad andmistegevusi erinevatest konkurentsikeskkondadest, pakkudes eksklusiivset juurdepääsu oma olekule.

actor DataStore {
    private var data: [String] = []

    func addData(_ item: String) {
        data.append(item)
    }

    func getData() -> [String] {
        return data
    }
}

let store = DataStore()

Task {
    await store.addData("item1")
}

Valik GCD, Operation Queue-de ja Concurrency vahel sõltub ülesande keerukusest, vajaliku kontrollitaseme ja koodistruktuuri nõuetest. Concurrency on kaasaegsete rakenduste eelistatud lähenemisviis, kuna see on loetav ja turvaline.

Miks ei soovitata iOS-is peamist niiti koormata ja millised on viisid selle vältimiseks?