Miért nem ajánlott az iOS fő szálat túlterhelni, és…

A fő szál felelős a felhasználói felület frissítéséért és az UI események kezeléséért. Bármilyen hosszú művelet (hálózati kérések, nehéz számítások, fájlműveletek) a fő szálon blokkolja azt, ami "lefagyott" UI-hoz, alacsony alkalmazás-reaktivitáshoz és akár összeomláshoz (watchdog timeout) vezethet.

Az alábbi módszerek segítenek elkerülni a terhelést a fő szálon:

Grand Central Dispatch (GCD): Lehetővé teszi feladatok aszinkron végrehajtását háttér sorokon.

DispatchQueue.global(): Globális háttér sorok elérése különböző prioritásokkal.
DispatchQueue.main: A fő sor a UI frissítéséhez.
async { ... }: Kódblokk aszinkron végrehajtása.

// nehéz feladat végrehajtása háttér szálon
DispatchQueue.global(qos: .userInitiated).async {
    // nehéz számítások vagy hálózati kérés

    // UI frissítése a fő szálon
    DispatchQueue.main.async {
        // felhasználói felület frissítése
    }
}

Operation Queues (Operation & OperationQueue): Magasabb szintű absztrakció a GCD sorok felett, támogatva az operációk közötti függőségeket, megszakítást és szüneteltetést.

OperationQueue(): Operációs sor létrehozása.
Operation: Absztrakt osztály a sorba tehető feladatokhoz.
addOperation(_:): Feladat hozzáadása a sorhoz.

let downloadOperation = BlockOperation {
    // adatok letöltése
}

let parseOperation = BlockOperation {
    // adatok feldolgozása
}

// függőség: a feldolgozás a letöltés után kezdődik
parseOperation.addDependency(downloadOperation)

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

Concurrency (async/await): Modern megközelítés Swiftben az aszinkron programozáshoz.

async: Egy függvény aszinkronnak jelölése.
await: Várakozás egy aszinkron művelet befejezésére.
Task: Új párhuzamos feladat létrehozása.

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()
            // adatok feldolgozása
            // UI frissítése automatikusan a fő szálon
            // (ha a Task a fő Actorban vagy DispatchQueue.main-ben jön létre)
        } catch {
            // hiba kezelése
        }
    }
}

Actors: Megelőzik az adatok versenyét, amikor különböző párhuzamos kontextusokból érik el őket, biztosítva kizárólagos hozzáférést az állapotukhoz.

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

A GCD, az Operation Queues és a Concurrency közötti választás a feladat összetettségétől, a szükséges kontroll szintjétől és a kód szerkezetének követelményeitől függ. A Concurrency a modern alkalmazásokban előnyben részesített megközelítés az olvashatóság és a biztonság miatt.

Miért nem ajánlott az iOS fő szálat túlterhelni, és milyen módszerek vannak ennek elkerülésére?