De ce nu este recomandat să supraîncărcați firul…

Firul principal răspunde de actualizarea interfeței utilizatorului și de gestionarea evenimentelor UI. Orice operație de durată lungă (solicitări de rețea, calcule intensive, lucru cu fișiere) pe firul principal îl va bloca, ceea ce va duce la o interfață "înghețată", la o răspunsivitate scăzută a aplicației și chiar la blocarea acesteia (timeout watchdog).

Modalități de a evita suprasarcina firului principal:

Grand Central Dispatch (GCD): Permite executarea asincronă a sarcinilor pe cozi de fundal.

DispatchQueue.global(): Acces la cozi globale de fundal cu priorități diferite.
DispatchQueue.main: Coada principală pentru actualizarea UI.
async { ... }: Executarea asincronă a unui bloc de cod.

// executarea unei sarcini grele în fundal
DispatchQueue.global(qos: .userInitiated).async {
    // calcule grele sau solicitare de rețea

    // actualizarea UI pe firul principal
    DispatchQueue.main.async {
        // actualizează interfața utilizatorului
    }
}

Cozi de operații (Operation & OperationQueue): O abstracție de nivel superior peste cozi GCD, care suportă dependențe între operații, anulare și suspendare.

OperationQueue(): Crearea unei cozi de operații.
Operation: Clasă abstractă pentru sarcini care pot fi adăugate în coadă.
addOperation(_:): Adăugarea unei operații în coadă.

let downloadOperation = BlockOperation {
    // descărcare date
}

let parseOperation = BlockOperation {
    // analizare date
}

// dependență: analiza începe după descărcare
parseOperation.addDependency(downloadOperation)

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

Concurență (async/await): Abordare modernă în Swift pentru programarea asincronă.

async: Marchează o funcție ca fiind asincronă.
await: Așteaptă finalizarea unei operații asincrone.
Task: Creează o nouă sarcină concurentă.

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()
            // procesare date
            // actualizare UI pe firul principal automat
            // (dacă Task-ul este creat în Actor-ul principal sau DispatchQueue.main)
        } catch {
            // tratarea erorii
        }
    }
}

Actori: Previn condiții de cursă la accesul din diferite contexte concurente, asigurând acces exclusiv la starea lor.

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

Alegerea între GCD, Cozi de operații și Concurență depinde de complexitatea sarcinii, nivelul de control necesar și cerințele de structurare a codului. Concurența este abordarea preferată în aplicațiile moderne datorită lizibilității și siguranței.

De ce nu este recomandat să supraîncărcați firul principal în iOS și care sunt modalitățile de a evita acest lucru?