Go Academy · Aula

Limitação de goroutines

Controle a simultaneidade

Aula 3 de 413 etapas

Limitação de goroutines é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 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 Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Limitando a concorrência

Às vezes, não se limita por segundo; limita-se quantas gorrotinas são executadas ao mesmo tempo. Isso limita a carga simultânea sobre um recurso, independentemente do momento em que ocorre.

Limita o paralelismo
Protege os conjuntos de conexões
Evita picos de uso de memória

O canal semáforo

Um canal com buffer funciona como um semáforo de contagem. Sua capacidade é igual à concorrência máxima. Adquirir envia um token; liberar recebe um token.

sem := make(chan struct{}, 3)

Aquisição e liberação

Antes de iniciar o trabalho, envie um token ao canal para adquirir uma vaga (a operação bloqueia se o canal estiver cheio). Ao terminar, receba um token para liberar a vaga, disponibilizando-a para outra gorrotina.

sem <- struct{}{}        // acquire
// do work
<-sem                    // release

Por que struct{}

Uma estrutura vazia struct{}{} ocupa zero bytes. Usá-la como elemento do canal transforma o semáforo em um sinal puro, sem desperdício de memória.

Limitando um laço

Inicie uma gorrotina por tarefa, mas faça cada uma passar pelo semáforo. No máximo cap gorrotinas realizam trabalho de verdade simultaneamente; as demais bloqueiam na aquisição.

for _, task := range tasks {
    sem <- struct{}{}
    go func(t Task) {
        defer func() { <-sem }()
        process(t)
    }(t)
}

Combinando com WaitGroup

O semáforo limita a concorrência, mas não informa quando tudo termina. Combine-o com um sync.WaitGroup para aguardar todas as tarefas.

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    defer func() { <-sem }()
    process(t)
}()

Libere em defer

Sempre libere em um defer para que a vaga seja liberada mesmo que o trabalho entre em pânico ou retorne antecipadamente. Esquecer de liberar deixa vagas ocupadas e, por fim, bloqueia novas aquisições.

Uma execução completa com limitação

Este programa executa oito tarefas com no máximo duas simultâneas, imprimindo o início e o fim para mostrar o limite em ação.

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    sem := make(chan struct{}, 2)
    var wg sync.WaitGroup
    for i := 0; i < 8; i++ {
        wg.Add(1)
        sem <- struct{}{}
        go func(id int) {
            defer wg.Done()
            defer func() { <-sem }()
            fmt.Println("start", id)
            time.Sleep(20 * time.Millisecond)
            fmt.Println("end", id)
        }(i)
    }
    wg.Wait()
    fmt.Println("done")
}

errgroup com SetLimit

O pacote golang.org/x/sync/errgroup oferece SetLimit para limitar um grupo e propagar o primeiro erro. É uma alternativa mais simples em muitos casos, embora seja um pacote externo.

Limitação versus conjunto de trabalhadores

Um conjunto de trabalhadores reutiliza um grupo fixo de gorrotinas que retiram tarefas de uma fila. A limitação por semáforo inicia uma gorrotina por tarefa, mas limita as que ficam ativas. Conjuntos de trabalhadores são mais econômicos para quantidades enormes de tarefas; semáforos são mais simples de adicionar.

Escolhendo o limite

Para chamadas ao banco de dados, defina o limite no máximo igual ao tamanho do conjunto de conexões. Para HTTP de saída, corresponda-o ao limite de conexões do host. Um valor alto demais causa esgotamento de recursos; um valor baixo demais desperdiça capacidade.

Verificação rápida

Teste seus conhecimentos sobre limitação.

Responda na aula interativa

Recapitulação

Você aprendeu sobre a limitação de gorrotinas:

Um canal com buffer funciona como um semáforo de contagem
Adquira enviando e libere recebendo em defer
Elementos struct{} custam zero bytes
Combine com WaitGroup para aguardar a conclusão
Dimensione o limite de acordo com o recurso protegido

Grátis para começar

Aprenda Go com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Limitação de goroutines” é grátis?

Sim — o texto completo de “Limitação de goroutines” é 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 Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Limitação de goroutines”?

Controle a simultaneidade Você pratica Go 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 Go Academy?

Nenhuma experiência prévia é necessária. Go 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 3 de 4.

Quanto tempo leva a aula “Limitação de goroutines”?

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 Go Academy?

Sim. Cada aula de Go 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 Go Academy