Swift Academy · Aula

Agendadores e Execução em Threads

Controle a execução com receive(on:) e subscribe(on:).

Agendadores e Execução em Threads é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Agendadores no Combine

Um agendador no Combine define quando e onde o trabalho é executado — qual linha de execução ou fila executa os operadores e entrega os valores aos assinantes.

Controlar os agendadores é essencial para manter as atualizações da interface na linha de execução principal e o trabalho pesado fora dela.

Dois operadores fundamentais

O Combine oferece dois operadores para controlar a execução em diferentes linhas:

subscribe(on:) — controla onde a inscrição e o trabalho a montante começam
receive(on:) — controla onde os valores a jusante são entregues

Eles afetam extremidades diferentes do fluxo.

receive(on:)

receive(on:) move tudo o que vem depois dele para o agendador fornecido. O uso mais comum é voltar para a fila principal antes de atualizar a interface.

apiClient.fetchUser(id: 1)
    .receive(on: DispatchQueue.main)
    .sink { user in
        self.nameLabel.text = user.name
    }
    .store(in: &cancellables)

subscribe(on:)

subscribe(on:) controla a linha de execução na qual o publisher começa a produzir valores e onde os operadores a montante são executados. Use-o para tirar configurações dispendiosas da linha principal.

heavyPublisher
    .subscribe(on: DispatchQueue.global(qos: .userInitiated))
    .receive(on: DispatchQueue.main)
    .sink { result in
        self.update(result)
    }
    .store(in: &cancellables)

subscribe(on:) versus receive(on:)

Lembre-se das direções:

subscribe(on:) afeta o fluxo a montante — onde o trabalho começa
receive(on:) afeta o fluxo a jusante — onde os resultados são entregues

Um padrão típico usa subscribe(on:) para o trabalho em background e receive(on:) para a entrega na linha principal.

DispatchQueue como agendador

DispatchQueue está em conformidade com o protocolo Scheduler. DispatchQueue.main entrega os valores na linha de execução principal; as filas globais são executadas concorrentemente em background.

let background = DispatchQueue.global(qos: .background)

publisher
    .map { expensiveTransform($0) }
    .subscribe(on: background)
    .receive(on: DispatchQueue.main)
    .sink { self.render($0) }
    .store(in: &cancellables)

RunLoop como agendador

RunLoop é outro agendador, vinculado ao ciclo de execução de uma linha de execução. RunLoop.main entrega os valores em coordenação com os eventos da interface, o que pode ser importante para aspectos como a capacidade de resposta durante a rolagem.

timerPublisher
    .receive(on: RunLoop.main)
    .sink { _ in
        self.tick()
    }
    .store(in: &cancellables)

DispatchQueue versus RunLoop

Ambos podem entregar valores na linha de execução principal, mas diferem sutilmente:

DispatchQueue.main — agenda o trabalho até mesmo durante o acompanhamento da rolagem
RunLoop.main — adia o trabalho enquanto o ciclo de execução está no modo de acompanhamento

Para a maioria das atualizações da interface após um trabalho assíncrono, DispatchQueue.main é a opção padrão mais segura.

Operadores de temporização de agendadores

Operadores como debounce, throttle e delay recebem um argumento de agendador que decide qual fila controla a temporização.

searchTextPublisher
    .debounce(for: .milliseconds(300), scheduler: DispatchQueue.main)
    .sink { query in
        self.runSearch(query)
    }
    .store(in: &cancellables)

Um erro comum de execução em linhas diferentes

Atualizar a interface fora da linha de execução principal causa falhas ou problemas visuais. Se você esquecer receive(on: DispatchQueue.main) depois de um publisher em background, seu sink poderá ser executado em uma linha de execução em background.

Sempre entregue os valores destinados à interface no agendador principal.

Juntando tudo

Um fluxo robusto inicia o trabalho em background, processa-o nesse contexto e depois o entrega à linha de execução principal para exibição.

imageURLPublisher
    .subscribe(on: DispatchQueue.global())
    .flatMap { url in downloadImage(url) }
    .map { resize($0) }
    .receive(on: DispatchQueue.main)
    .sink { self.imageView.image = $0 }
    .store(in: &cancellables)

Verificação rápida

Verifique seus conhecimentos sobre agendadores.

Resumo

Você aprendeu a controlar a execução em diferentes linhas no Combine:

subscribe(on:) — onde o trabalho a montante começa
receive(on:) — onde os resultados são entregues
DispatchQueue e RunLoop como agendadores
Sempre entregue as atualizações da interface na linha de execução principal

Um agendamento adequado mantém os aplicativos responsivos e livres de falhas.

Perguntas Frequentes

A aula “Agendadores e Execução em Threads” é grátis?

Sim — o texto completo de “Agendadores e Execução em Threads” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Agendadores e Execução em Threads”?

Controle a execução com receive(on:) e subscribe(on:). Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Agendadores e Execução em Threads”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy