Quais mecanismos de multitarefa são usados no iOS…

No iOS, utilizam-se os seguintes mecanismos principais de multitarefa:

Grand Central Dispatch (GCD):
- Mecanismo de alto nível para gestão de paralelismo.
- Baseado em filas de tarefas (dispatch queues).
- Permite executar blocos de código de forma assíncrona ou síncrona.
- Diferenciam-se filas sequenciais (serial) e paralelas (concurrent), bem como filas globais (global) paralelas.
- Método preferido para a maioria das tarefas de multitarefa.
```
// Executar tarefa numa thread em segundo plano usando GCD
DispatchQueue.global(qos: .userInitiated).async {
    // Operação prolongada
    DispatchQueue.main.async {
        // Atualizar UI na thread principal
    }
}
```
Operações e filas de operações:
- Abordagem orientada a objetos para gerir tarefas.
- Operation - classe abstrata que representa uma tarefa.
- OperationQueue - fila que gere a execução de objetos Operation.
- Suportam dependências entre operações, prioridades, cancelamentos e herança.
- Mecanismo mais flexível e complexo do que GCD, adequado para cenários de gestão de tarefas mais complexos.
```
// Criar e adicionar operação à fila
let operation = BlockOperation {
    // Tarefa da operação
    print("Operação executada")
}

let operationQueue = OperationQueue()
operationQueue.addOperation(operation)
```
Threads (Pthreads):
- Mecanismo de baixo nível, mais próximo do sistema.
- Gestão direta de threads através da API POSIX Threads.
- Requer gestão manual do ciclo de vida das threads (criação, finalização, sincronização).
- Mais complexo e propenso a erros (por exemplo, condições de corrida) comparado com GCD e Operações.
- Geralmente usado apenas em cenários específicos e de baixo nível, quando as APIs de nível superior não são suficientes. Raramente no desenvolvimento moderno de iOS.
```
// Exemplo de criação de thread com Pthreads
// (o seu uso em Swift requer wrappers ou interop com C)

/*
#include <pthread.h>

void* thread_function(void* arg) {
    // Código do thread
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    pthread_join(thread, NULL); // Esperar pela conclusão do thread
    return 0;
}
*/
```
Atores (Concurrência Swift):
- Mecanismo novo apresentado no Swift 5.5 como parte do Swift Concurrency.
- Destinado a trabalhar de forma segura com estado modificável em ambientes concorrentes.
- Garantem acesso ao seu estado apenas para uma tarefa de cada vez, prevenindo condições de corrida.
- São usados com funções assíncronas (async/await).
- Abordagem recomendada para gerir estado em cenários multithread em Swift.
```
actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        value
    }
}

// Uso do Actor
// let counter = Counter()
// await counter.increment()
// let currentValue = await counter.getValue()
```

Tabela comparativa dos mecanismos principais:

Mecanismo	Nível de abstração	Gestão	Segurança (condições de corrida)	Uso
GCD	Alto	Filas de tarefas (blocos de código)	Médio*	Tarefas gerais, operações assíncronas
Operações & Filas	Médio	Objetos de tarefa (`Operation`)	Médio*	Tarefas mais complexas, dependências
Threads (Pthreads)	Baixo	Gestão direta de threads	Baixo (sincronização manual)	Tarefas específicas e de baixo nível (pouco frequente)
Atores (Concurrência Swift)	Alto**	Isolamento de estado (`actor`)	Alto	Gestão de estado modificável em código assíncrono

** A segurança do GCD e das Operações depende de uma sincronização correta do acesso a recursos partilhados (por exemplo, usando DispatchQueue.sync, NSLock, semáforros). ** Nível alto para gerir estado de forma segura, integrado na sintaxe assíncrona.

No desenvolvimento moderno de iOS, recomenda-se usar GCD, Operações e Atores, evitando a gestão direta de threads via Pthreads, salvo se absolutamente necessário.

Quais mecanismos de multitarefa são usados no iOS?