Neste artigo, você aprenderá como integrar async/await em fluxos de dados, entenderá seus benefícios e verá exemplos práticos que o ajudarão a dominar essa funcionalidade essencial para o desenvolvimento iOS moderno.

📽️

Antes de mergulharmos nos detalhes sobre o uso de async/await em fluxos de dados no Swift, confira este vídeo que apresenta uma visão geral da linguagem e suas funcionalidades modernas. Ele é uma ótima introdução para quem está começando agora ou quer reforçar os fundamentos do Swift.

O que é async/await?

• async: Um aviso ao Swift de que uma função pode levar tempo para ser concluída sem travar o restante do app.

• await: Um comando para "pausar" a execução e aguardar o término de uma tarefa assíncrona.

func fetchData(completion: @escaping (Data) -> Void) {
    // ... código para buscar dados ...
    completion(data)
}

fetchData { data in
    // ... processar dados ...
}

func fetchData() async -> Data {
    // ... código para buscar dados ...
    return data
}

let data = await fetchData()
// ... processar dados ...

Fluxos de dados na prática

func streamOfNumbers() -> AsyncStream<Int> {
    AsyncStream { continuation in
        var number = 0
        Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in
            number += 1
            continuation.yield(number) // Emite um novo valor
        }
    }
}

for await number in streamOfNumbers() {
    print("Número recebido: \(number)")
    if number >= 10 { break }
}

Entendendo o exemplo

• AsyncStream: cria uma sequência assíncrona de valores.

• continuation.yield: emite valores à medida que eles ficam disponíveis.

• for await: itera sobre os valores emitidos pela sequência.

Este código ilustra a simplicidade e clareza do async/await comparado ao uso de callbacks. Ele mantém o app responsivo enquanto processa dados continuamente.

Async/await no fluxo de dados em Swift

• Atualizações em tempo real de localização do usuário.

• Streaming de dados como mensagens de chat ou transmissões ao vivo.

• Manipulação de grandes conjuntos de dados recebidos de APIs.

Como representar fluxos de dados?

func liveChatMessages() -> AsyncStream<String> {
    AsyncStream { continuation in
        Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { _ in
            let newMessage = "Nova mensagem recebida às \(Date())"
            continuation.yield(newMessage) // Envia a mensagem para o fluxo
        }
    }
}

Task {
    for await message in liveChatMessages() {
        print(message)
    }
}

O que está acontecendo aqui?

1. AsyncStream: permite criar um fluxo assíncrono que emite valores de forma contínua.

2. continuation.yield: é usado para "empurrar" novos dados para o fluxo.

3. for await: itera sobre o fluxo, processando cada mensagem recebida.

Com esse padrão, é possível lidar com fluxos de dados sem bloquear outras partes do aplicativo, garantindo que a interface do usuário permaneça responsiva.

Cancelando e gerenciando fluxos

Task {
    for await message in liveChatMessages() {
        if Task.isCancelled {
            print("Fluxo cancelado.")
            break
        }
        print(message)
    }
}

Esse controle granular ajuda a evitar desperdício de recursos e mantém a experiência do usuário fluida, mesmo em operações mais complexas.

Por que isso importa?

Ganhos de performance e responsividade

1. Gerencie suas tarefas: encerre fluxos assíncronos desnecessários assim que não forem mais necessários, evitando o consumo indevido de memória e processamento.

2. Use prioridades adequadas: ajuste a prioridade das tarefas conforme sua importância. Tarefas não críticas podem rodar com menor prioridade, liberando recursos para as operações principais da interface.

3. Monitoramento e profiling: utilize ferramentas como o Instruments do Xcode para identificar gargalos e pontos de melhoria, garantindo que a adoção de async/await traga ganhos reais de desempenho.

Tratamento de erros com async/await

do {
    for await number in streamOfNumbers() {
        if number == 5 {
            throw MyError.unexpectedError // Erro proposital
        }
        print("Número recebido: \(number)")
    }
} catch {
    print("Erro ao processar o fluxo: \(error)")
}

Aqui, o fluxo é interrompido ao atingir o número 5, e o erro é capturado no bloco catch. Essa abordagem deixa claro onde e como os erros são tratados.

Dicas e boas práticas

• Legibilidade em primeiro lugar: async/await melhora a clareza do código. Use-o sempre que possível para substituir callbacks complexos.

• Gerenciamento de memória: tarefas assíncronas podem consumir recursos. Certifique-se de liberar referências não utilizadas.

• Teste e pratique: o domínio de async/await requer prática constante. Experimente aplicar essas técnicas em projetos pequenos.

Por que usar async/await?

Referências e material extra

• Apple Developer Documentation - Concurrency

• Meet Swift Async Algorithms

• Comece com Swift: Guia para Iniciantes

• Swift Playgrounds: Aprenda Programação Brincando

• Swift: Programação Descomplicada

Conclusão