0Pricing
Swift Academy · Aula

Concorrência estruturada, funções assíncronas

Defina funções async , chame-as com await e entenda a concorrência estruturada : as tarefas filhas terminam antes de o escopo pai ser encerrado.

Concorrência estruturada, funções assíncronas é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 3. 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 3 aulas no total.

Por que usar async/await?

async/await permite escrever código assíncrono que se lê como código síncrono. Com a concorrência estruturada, as tarefas filhas ficam vinculadas aos tempos de vida dos escopos — sem vazamentos.

Sua primeira função assíncrona

Uma função async pode usar await com outro trabalho assíncrono. Crie uma Task em scripts ou playgrounds para chamá-la.

// Simulate a short async delay, then return a value
func fetchNumber() async -> Int {
    try? await Task.sleep(nanoseconds: 200_000_000) // ~200ms
    return 42
}

// Call sites must use "await" from an async context or a Task
Task {
    let n = await fetchNumber()
    print("Fetched:", n)  // 42
}

Suspensão e retomada

await suspende a tarefa até que o resultado esteja pronto; então, a execução é retomada corretamente na linha seguinte.

func greet(after seconds: Double) async -> String {
    let ns = UInt64(seconds * 1_000_000_000)
    try? await Task.sleep(nanoseconds: ns)
    return "Hello after \(Int(seconds))s"
}

Task {
    print(await greet(after: 1.0))
    print("Back on the same task after await.")
}

Noções básicas de async let

Use async let para iniciar tarefas filhas. Elas pertencem ao escopo atual e devem ser aguardadas antes que o escopo termine.

// Run child tasks concurrently within the same scope
func fetchUser() async -> String { "Ana" }
func fetchScore() async -> Int { 90 }

Task {
    async let name = fetchUser()
    async let score = fetchScore()
    // Both start immediately; await joins them before use
    let summary = await "\(name): \(score)"
    print(summary) // "Ana: 90"
    // Scope ends -> child tasks are awaited automatically (structured)
}

As tarefas pai aguardam as filhas

Estruturada significa que as tarefas pai não podem terminar antes das filhas. Isso evita trabalho órfão e torna os tempos de vida previsíveis.

// Parent Task encapsulates children lifetimes
func loadProfile() async -> String {
    async let name = fetchUser()
    async let score = fetchScore()
    return await "\(name) (\(score))"
}

Task {
    let profile = await loadProfile()
    print(profile) // e.g., "Ana (90)"
    // loadProfile does not return until its children are done
}

Diretrizes

Dicas:

  • Pense em tarefas, não em threads.
  • Use async let para trabalhos irmãos; use await antes que o escopo termine.
  • Use Task.sleep para demonstrações; em aplicativos reais, aguarde operações de E/S de rede ou de arquivos.

Definição de await

Verificação rápida: o que await faz?

Recapitulação

Recapitulação: marque as funções como async e chame-as com await. Use async let para iniciar tarefas irmãs e conte com a concorrência estruturada para encerrar as filhas antes das tarefas pai.

Perguntas Frequentes

A aula “Concorrência estruturada, funções assíncronas” é grátis?

Sim — o texto completo de “Concorrência estruturada, funções assíncronas” é 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 3 aulas no total.

O que vou aprender em “Concorrência estruturada, funções assíncronas”?

Defina funções async , chame-as com await e entenda a concorrência estruturada : as tarefas filhas terminam antes de o escopo pai ser encerrado. 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 1 de 3.

Quanto tempo leva a aula “Concorrência estruturada, funções assíncronas”?

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

  1. Concorrência estruturada, funções assíncronas
  2. async let, Task e cancelamento
  3. try await e propagação de erros
← Voltar para Swift Academy