O que pode contar sobre o Grand Central Dispatch e…

O Grand Central Dispatch (GCD) é uma API de baixo nível para gerir operações paralelas, baseada no conceito de execução assíncrona de tarefas em processadores multinúcleo. Ele fornece grupos de threads geridos pelo sistema, libertando o desenvolvedor de criar e gerir threads manualmente.

Componentes principais:

Filas de despacho (Dispatch Queues): Estruturas de dados que contêm blocos de tarefas (workItem) para execução. As tarefas são executadas na ordem de inserção.
- Filas sequenciais (Serial Queues): Executam tarefas uma a uma, na ordem de inserção. Garantem a ordem de execução e a segurança dos dados modificados apenas numa fila.
- Filas paralelas (Concurrent Queues): Executam tarefas em paralelo, usando os recursos do sistema disponíveis. A ordem de conclusão das tarefas não é garantida.
  - Filas paralelas globais (Global Concurrent Queues): Fornecidas pelo sistema com diferentes prioridades (qos): .userInteractive, .userInitiated, .default, .utility, .background.
- Fila principal (Main Queue): Fila sequencial especial ligada ao thread principal da aplicação (main thread). Usada para atualizar a interface de utilizador.
Work Items (Itens de Trabalho): Closures ou funções enviadas pelo GCD para execução.
Grupos de despacho (Dispatch Groups): Permitem executar tarefas em várias filas e receber notificação ao concluir todas as tarefas do grupo.
Semáforos de despacho (Dispatch Semaphores): Mecanismo para limitar o número de threads que acedem simultaneamente a um recurso, ou para sincronizar entre threads.

Utilização em desenvolvimento iOS:

Execução assíncrona de tarefas: Transferir operações intensivas em recursos (requisições de rede, trabalho com bases de dados, processamento de imagens) do thread principal para filas em segundo plano para manter a capacidade de resposta da interface.

let queue = DispatchQueue.global(qos: .userInitiated)
queue.async {
    // Executar operação intensiva
    let result = performHeavyCalculation()

    DispatchQueue.main.async {
        // Atualizar UI no thread principal
        self.updateUI(with: result)
    }
}

Sincronização:

Semáforos para limitar o acesso a recursos partilhados.

let semaphore = DispatchSemaphore(value: 1) // Permite 1 thread aceder
semaphore.wait() // Espera até o semáforo estar disponível
// Acesso ao recurso partilhado
semaphore.signal() // Liberta o semáforo

Filas sequenciais para garantir a segurança dos dados.

Execução em grupo: Executar várias tarefas assíncronas e aguardar a sua conclusão.

let group = DispatchGroup()
let concurrentQueue = DispatchQueue.global()

group.enter() // Entrada no grupo
concurrentQueue.async {
    // Tarefa 1
    print("Tarefa 1 concluída")
    group.leave() // Saída do grupo
}

group.enter()
concurrentQueue.async {
    // Tarefa 2
    print("Tarefa 2 concluída")
    group.leave()
}

group.notify(queue: .main) {
    // Todas as tarefas do grupo foram concluídas
    print("Todas as tarefas concluídas")
}

Execução diferida: Executar código após um intervalo de tempo.

DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
    // Código será executado após 2 segundos
    print("Execução diferida")
}

Vantagens do GCD:

Facilidade de uso em comparação com a gestão manual de threads.
Gestão do grupo de threads pelo sistema, otimizada para processadores multinúcleo.
Uso eficiente de recursos.
Evita problemas associados à gestão manual de threads (condições de corrida, deadlocks).

Desvantagens do GCD:

Menos flexível do que a gestão manual em alguns cenários complexos.
Depuração de código multithread pode ser difícil.

O que pode contar sobre o Grand Central Dispatch e seu uso no desenvolvimento iOS?