Koji mehanizmi višestrukog izvršavanja se koriste u…

U iOS-u se koriste sledeći osnovni mehanizmi za višeprocesno izvršavanje:

Grand Central Dispatch (GCD):
- Visok nivo mehanizma za upravljanje paralelizmom.
- Osnovan na redovima zadataka (dispatch queues).
- Omogućava izvršavanje blokova koda asinhrono ili sinhrono.
- Razlikuju se sekvencijalni (serial) i paralelni (concurrent) redovi, kao i globalni (global) paralelni redovi.
- Preferirani način rada sa višeprocesnošću za većinu zadataka.
```
// Izvršavanje zadatka u pozadinskom thread-u pomoću GCD
DispatchQueue.global(qos: .userInitiated).async {
    // Duga operacija
    DispatchQueue.main.async {
        // Ažuriranje UI u glavnom thread-u
    }
}
```
Operations and Operation Queues:
- Objektno-orijentisan pristup upravljanju zadacima.
- Operation - apstraktna klasa koja predstavlja poseban zadatak.
- OperationQueue - red koji upravlja izvršavanjem objekata Operation.
- Podržavaju zavisnosti između operacija, prioritete, otkazivanje i nasledjivanje.
- Fleksibilniji i složeniji mehanizam od GCD-a, pogodan za složenije scenarije upravljanja zadacima.
```
// Kreiranje i dodavanje operacije u red
let operation = BlockOperation {
    // Zadatak operacije
    print("Operation executed")
}

let operationQueue = OperationQueue()
operationQueue.addOperation(operation)
```
Threads (Pthreads):
- Nisko nivo mehanizma, bliže sistemskom nivou.
- Direktno upravljanje thread-ovima putem API-ja POSIX Threads.
- Zahteva ručno upravljanje životnim ciklusom thread-ova (kreiranje, završetak, sinhronizacija).
- Složeniji i podložniji greškama (npr. trke podataka) u poređenju sa GCD-om i Operations.
- Obično se koristi samo u specifičnim, niskonivo zadacima, kada su API-ji višeg nivoa nedovoljni. Retko se koristi u savremenom iOS razvoju.
```
// Primer kreiranja thread-a pomoću Pthreads
// (korišćenje u Swift-u zahteva omote ili C-interoperabilnost)

/*
#include <pthread.h>

void* thread_function(void* arg) {
    // Kod thread-a
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    pthread_join(thread, NULL); // Čekanje završetka thread-a
    return 0;
}
*/
```
Actors (Swift Concurrency):
- Novi mehanizam, predstavljen u Swift 5.5 kao deo Swift Concurrency.
- Namenjen za sigurnu rad sa promenljivim stanjem u konkurentnoj sredini.
- Garantuje pristup svom stanju samo za jednu zadatak odjednom, sprečavajući trke podataka.
- Koristi se sa asinhronim funkcijama (async/await).
- Preporučeni pristup za upravljanje stanjem u višeprocesnim scenarijima u Swift-u.
```
actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        value
    }
}

// Korišćenje Actor-a
// let counter = Counter()
// await counter.increment()
// let currentValue = await counter.getValue()
```

Uporedna tabela osnovnih mehanizama:

Mehanizam	Nivo apstrakcije	Upravljanje	Bezbednost (trke podataka)	Korišćenje
GCD	Visok	Redovi zadataka (blokovi koda)	Srednji*	Opšte zadatke, asinhrone operacije
Operations & Queues	Srednji	Objekti zadataka (`Operation`)	Srednji*	Složenije zadatke, zavisnosti
Threads (Pthreads)	Nizak	Direktno upravljanje thread-ovima	Nizak (ručna sinhronizacija)	Specifični, niskonivo zadaci (retko)
Actors (Swift Concurrency)	Visok**	Izolacija stanja (`actor`)	Visok	Upravljanje promenljivim stanjem u asinhronom kodu

* Bezbednost GCD i Operations zavisi od pravilne sinhronizacije pristupa zajedničkim resursima (npr. pomoću DispatchQueue.sync, NSLock, semafora). ** Visok nivo za sigurno upravljanje stanjem, integrisan sa asinhronim sintaksama.

U savremenom iOS razvoju, preporučljivo je koristiti GCD, Operations i Actors, izbegavajući direktno upravljanje thread-ovima pomoću Pthreads, osim ako to nije apsolutno neophodno.

Koji mehanizmi višestrukog izvršavanja se koriste u iOS-u?