Aké mechanizmy viacvláknového spracovania sa…

V iOS sa používajú nasledujúce základné mechanizmy viacvláknového spracovania:

Grand Central Dispatch (GCD):
- Vysokoúrovňový mechanizmus riadenia paralelizmu.
- Založený na frontoch úloh (dispatch queues).
- Umožňuje vykonávať bloky kódu asynchrónne alebo synchronizovane.
- Rozlišujú sa sekvenčné (serial) a paralelné (concurrent) fronty, ako aj globálne (global) paralelné fronty.
- Preferovaný spôsob práce s viacvláknovým spracovaním pre väčšinu úloh.
```
// Spustenie úlohy vo фоновom vlákne pomocou GCD
DispatchQueue.global(qos: .userInitiated).async {
    // Dlhá operácia
    DispatchQueue.main.async {
        // Aktualizácia UI v hlavnom vlákne
    }
}
```
Operations and Operation Queues:
- Objektovo-orientovaný prístup k riadeniu úloh.
- Operation - abstraktná trieda reprezentujúca samostatnú úlohu.
- OperationQueue - front, ktorý riadi vykonávanie objektov Operation.
- Podporujú závislosti medzi operáciami, priority, zrušenie a dedičnosť.
- Flexibilnejší a zložitejší mechanizmus ako GCD, vhodný pre komplexnejšie scenáre riadenia úloh.
```
// Vytvorenie a pridanie operácie do frontu
let operation = BlockOperation {
    // Úloha operácie
    print("Operation executed")
}

let operationQueue = OperationQueue()
operationQueue.addOperation(operation)
```
Threads (Pthreads):
- Nízkoúrovňový mechanizmus, bližšie k systémovej úrovni.
- Priame riadenie vlákien cez API POSIX Threads.
- Vyžaduje manuálne riadenie životného cyklu vlákien (vytvorenie, ukončenie, synchronizácia).
- Zložitejší a náchylnejší na chyby (napríklad závody pri dátach) v porovnaní s GCD a Operations.
- Zvyčajne sa používa iba v špecifických, nízkoúrovňových scenároch, keď sú API vyššieho levelu nedostatočné. Veľmi zriedkavo sa používa v modernom iOS vývoji.
```
// Príklad vytvorenia vlákna pomocou Pthreads
// (použitie v Swift vyžaduje obaly alebo C-interoperabilitu)

/*
#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); // Čakanie na ukončenie vlákna
    return 0;
}
*/
```
Actors (Swift Concurrency):
- Nový mechanizmus predstavený v Swift 5.5 ako súčasť Swift Concurrency.
- Určený na bezpečnú prácu so zmeniteľným stavom v konkurenčnom prostredí.
- Zaručujú prístup k svojmu stavu iba jednej úlohe naraz, čím zabraňujú závodom pri dátach.
- Používajú sa s asynchrónnymi funkciami (async/await).
- Odporúčaný prístup na riadenie stavu v viacvláknových scenároch v Swift.
```
actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        value
    }
}

// Použitie Actor
// let counter = Counter()
// await counter.increment()
// let currentValue = await counter.getValue()
```

Porovnávacia tabuľka hlavných mechanizmov:

Mechanizmus	Úroveň abstrakcie	Riadenie	Bezpečnosť (závody pri dátach)	Použitie
GCD	Vysoká	Fronty úloh (bloki kódu)	Stredná*	Bežné úlohy, asynchrónne operácie
Operations & Queues	Stredná	Objekty úloh (`Operation`)	Stredná*	Zložitejšie úlohy, závislosti
Threads (Pthreads)	Nízka	Priame riadenie vlákien	Nízka (ručná synchronizácia)	Špecifické, nízkoúrovňové úlohy (zriedkavo)
Actors (Swift Concurrency)	Vysoká**	Izolácia stavu (`actor`)	Vysoká	Riadenie zmeniteľného stavu v asynchrónnom kóde

* Bezpečnosť GCD a Operations závisí od správnej synchronizácie prístupu k spoločným zdrojom (napríklad pomocou DispatchQueue.sync, NSLock, semaforov). ** Vysoká úroveň pre bezpečné riadenie stavu, integrovaná s asynchrónnym syntaxom.

V súčasnej iOS vývoji je vhodné používať GCD, Operations a Actors, pričom sa vyhýbať priamej správe vlákien pomocou Pthreads, ak to nie je absolútne nevyhnutné.

Aké mechanizmy viacvláknového spracovania sa používajú v iOS?