Jaké mechanismy vícevláknového zpracování se v iOS…

V iOS se používají následující hlavní mechanismy pro vícenásobné vlákno:

Grand Central Dispatch (GCD):
- Vysoceúrovňový mechanismus pro správu paralelismu.
- Založen na frontách úloh (dispatch queues).
- Umožňuje spouštět bloky kódu asynchronně nebo synchronně.
- Existují sekvenční (serial) a paralelní (concurrent) fronty, stejně jako globální (global) paralelní fronty.
- Preferovaný způsob práce s vícenásobným vláknem pro většinu úloh.
```
// Spuštění úlohy na pozadí pomocí GCD
DispatchQueue.global(qos: .userInitiated).async {
    // Dlouhotrvající operace
    DispatchQueue.main.async {
        // Aktualizace UI na hlavním vlákně
    }
}
```
Operace a fronty operací:
- Objektově orientovaný přístup k řízení úloh.
- Operation - abstraktní třída představující samostatnou úlohu.
- OperationQueue - fronta, která řídí provádění objektů Operation.
- Podporují závislosti mezi operacemi, priority, zrušení a dědičnost.
- Flexibilnější a složitější mechanismus než GCD, vhodný pro složitější scénáře řízení úloh.
```
// Vytvoření a přidání operace do fronty
let operation = BlockOperation {
    // Úloha operace
    print("Operace provedena")
}

let operationQueue = OperationQueue()
operationQueue.addOperation(operation)
```
Vlákna (Pthreads):
- Nízké úrovně mechanismus, blíže k systému.
- Přímé řízení vláken pomocí API POSIX Threads.
- Ruční správa životního cyklu vláken (vytvoření, ukončení, synchronizace).
- Složitější a náchylnější k chybám (například závody o data) ve srovnání s GCD a operacemi.
- Obvykle se používá pouze v specifických, nízkoúrovňových scénářích, kdy vyšší API nestačí. Velmi vzácně se v moderním vývoji iOS vyskytuje.
```
// Příklad vytvoření vlákna pomocí Pthreads
// (použití ve Swift vyžaduje obalovače nebo C interop)

/*
#include <pthread.h>

void* thread_function(void* arg) {
    // Kód vlákna
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    pthread_join(thread, NULL); // Čekání na ukončení vlákna
    return 0;
}
*/
```
Herci (Swift Concurrency):
- Nový mechanismus představený ve Swift 5.5 jako součást Swift Concurrency.
- Navržen pro bezpečnou práci se změnitelným stavem v konkurenčním prostředí.
- Zaručuje, že přístup ke svému stavu je povolen pouze jedné úloze najednou, čímž předchází závodům o data.
- Používá se s asynchronními funkcemi (async/await).
- Doporučený přístup pro správu stavu ve vícestopých scénářích ve Swift.
```
actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        value
    }
}

// Použití herce
// let counter = Counter()
// await counter.increment()
// let currentValue = await counter.getValue()
```

Porovnávací tabulka hlavních mechanismů:

Mechanismus	Úroveň abstrakce	Řízení	Bezpečnost (závody o data)	Použití
GCD	Vysoká	Fronty úloh (bloky kódu)	Střední*	Obecné úlohy, asynchronní operace
Operace & Fronty	Střední	Objektové úlohy (`Operation`)	Střední*	Složitější úlohy, závislosti
Vlákna (Pthreads)	Nízká	Přímé řízení vláken	Nízké (ruční synchronizace)	Speciální, nízkoúrovňové úlohy (zřídka)
Herci (Swift Concurrency)	Vysoká**	Izolace stavu (`actor`)	Vysoké	Řízení měnitelného stavu v asynchronním kódu

* Bezpečnost GCD a Operací závisí na správné synchronizaci přístupu ke sdíleným zdrojům (například pomocí DispatchQueue.sync, NSLock, semaforů). ** Vysoká úroveň pro bezpečné řízení stavu, integrovaná s asynchronní syntaxí.

V moderním vývoji iOS je doporučeno používat GCD, Operace a Herci, vyhýbat se přímému řízení vláken přes Pthreads, pokud to není naprosto nezbytné.

Jaké mechanismy vícevláknového zpracování se v iOS používají?