Kāpēc nav ieteicams iOS galvenā pavediena pārslodze…

Galvenais pavedienu atbild par lietotāja saskarnes atjaunināšanu un UI notikumu apstrādi. Jebkuras ilgstošas operācijas (tīkla pieprasījumi, smagas aprēķini, darbs ar failiem) galvenajā pavedienā to bloķēs, kas novedīs pie "sasalusi" UI, zemas atsaucības lietojumprogrammai un pat tās avārijas (watchdog timeout).

Kā izvairīties no slodzes uz galveno pavedienu:

Grand Central Dispatch (GCD): ļauj veikt uzdevumus asinhroni fonu rindās.

DispatchQueue.global(): iegūst globālas fonu rindas ar dažādiem prioritātes līmeņiem.
DispatchQueue.main: galvenā rinda UI atjaunināšanai.
async { ... }: kodu bloka izpilde asinhroni.

// smagas uzdevuma izpilde fonā
DispatchQueue.global(qos: .userInitiated).async {
    // smagas aprēķini vai tīkla pieprasījums

    // UI atjaunināšana galvenajā pavedienā
    DispatchQueue.main.async {
        // lietotāja saskarnes atjaunināšana
    }
}

Operation rindas (Operation & OperationQueue): augstākā līmeņa abstrakcija pār Dispatch rindām, kas atbalsta atkarības starp operācijām, atcelšanu un pārtraukšanu.

OperationQueue(): operāciju rindu izveide.
Operation: abstrakts klases veids uzdevumiem, kurus var pievienot rindai.
addOperation(_:): operācijas pievienošana rindai.

let downloadOperation = BlockOperation {
    // datu lejupielāde
}

let parseOperation = BlockOperation {
    // datu apstrāde
}

// atkarība: apstrāde sākas pēc lejupielādes
parseOperation.addDependency(downloadOperation)

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

Concurrency (async/await): mūsdienīga pieeja Swift asinhronai programmēšanai.

async: atzīmē funkciju kā asinhronu.
await: gaida asinhronas operācijas pabeigšanu.
Task: izveido jaunu konkurējošu uzdevumu.

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()
            // datu apstrāde
            // UI atjaunināšana galvenajā pavedienā automātiski
            // (ja uzdevums tiek izpildīts galvenajā aktierī vai DispatchQueue.main)
        } catch {
            // kļūdas apstrāde
        }
    }
}

Actors: novērš datu sacensības, piekļūstot no dažādiem konkurējošiem kontekstiem, nodrošinot ekskluzīvu piekļuvi savai stāvokļa.

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")
}

Izvēle starp GCD, Operation rindām un Concurrency ir atkarīga no uzdevuma sarežģītības, nepieciešamā kontroles līmeņa un koda struktūras prasībām. Concurrency ir ieteicamāka pieeja mūsdienu lietojumprogrammās, ņemot vērā lasāmību un drošību.

Kāpēc nav ieteicams iOS galvenā pavediena pārslodze un kādi ir veidi, kā to izvairīties?