GenStage e Fluxos com Contrapressão
Crie fluxos de dados orientados pela procura com GenStage, nos quais os consumidores controlam o fluxo através de contrapressão para evitar sobrecargas em sistemas distribuídos.
GenStage e Fluxos com Contrapressão é uma aula grátis de Elixir & Phoenix: Scalable Backend Development no CoddyKit. Esta é a aula 4 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 Elixir & Phoenix: Scalable Backend Development, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Elixir & Phoenix: Scalable Backend Development inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
The Overload Problem
When a fast producer feeds a slow consumer, messages pile up and memory explodes. Backpressure solves this: consumers signal how much work they can handle, and producers send only that much.
What is GenStage?
GenStage is an Elixir behaviour for building staged, demand-driven pipelines. Data flows from producers to consumers, with optional producer-consumer stages in between.
The Three Stage Types
Every GenStage process plays one role:
- Producer: emits events on demand
- ProducerConsumer: receives, transforms, and re-emits
- Consumer: receives and processes events
Defining a Producer
A producer implements init/1 and handle_demand/2. It returns events only when consumers ask for them.
defmodule Counter do
use GenStage
def init(start), do: {:producer, start}
def handle_demand(demand, state) do
events = Enum.to_list(state..(state + demand - 1))
{:noreply, events, state + demand}
end
endDefining a Consumer
A consumer implements handle_events/3. It returns no events itself, only acknowledging the demand it processed.
defmodule Printer do
use GenStage
def init(_), do: {:consumer, :ok}
def handle_events(events, _from, state) do
for e <- events, do: IO.inspect(e)
{:noreply, [], state}
end
endSubscribing Stages
Connect a consumer to a producer with GenStage.sync_subscribe/2. The max_demand option caps how many events flow at once.
{:ok, prod} = GenStage.start_link(Counter, 0)
{:ok, cons} = GenStage.start_link(Printer, :ok)
GenStage.sync_subscribe(cons, to: prod, max_demand: 10)How Backpressure Works
The consumer requests up to max_demand events. The producer can never send more than was requested, so a slow consumer naturally throttles a fast producer. No buffering blowup.
Producer-Consumer Stages
A middle stage transforms data. It implements handle_events/3 but returns transformed events for the next stage.
def handle_events(events, _from, state) do
doubled = Enum.map(events, &(&1 * 2))
{:noreply, doubled, state}
endConsumerSupervisor
For concurrent processing, ConsumerSupervisor spawns a short-lived child process per event, bounded by demand. This parallelizes work while keeping backpressure intact.
Flow for Parallel Pipelines
The Flow library builds on GenStage to offer map/reduce-style parallel data processing with partitioning — ideal for crunching large collections across cores.
File.stream!("big.csv")
|> Flow.from_enumerable()
|> Flow.map(&parse_line/1)
|> Flow.partition()
|> Enum.to_list()When to Reach for GenStage
Use GenStage when you have:
- A rate mismatch between data source and processing
- Streaming data that must not overwhelm memory
- Multi-stage transformation pipelines
Quick Check
Test your GenStage knowledge.
Recap
You learned demand-driven pipelines:
- GenStage has producers, producer-consumers, and consumers
- Consumers request bounded demand for backpressure
- Subscribe stages with
sync_subscribeandmax_demand ConsumerSupervisorparallelizes per-event workFlowbuilds parallel map/reduce pipelines on top
Backpressure keeps distributed systems stable under load.
Aprenda Elixir 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
- 12
- Aulas
- 48
Perguntas Frequentes
A aula “GenStage e Fluxos com Contrapressão” é grátis?
Sim — o texto completo de “GenStage e Fluxos com Contrapressão” é 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 Elixir & Phoenix: Scalable Backend Development, atualize para CoddyKit PRO. O curso de Elixir & Phoenix: Scalable Backend Development inclui 4 aulas no total.
O que vou aprender em “GenStage e Fluxos com Contrapressão”?
Crie fluxos de dados orientados pela procura com GenStage, nos quais os consumidores controlam o fluxo através de contrapressão para evitar sobrecargas em sistemas distribuídos. Você pratica Elixir & Phoenix: Scalable Backend Development 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 Elixir & Phoenix: Scalable Backend Development?
Nenhuma experiência prévia é necessária. Elixir & Phoenix: Scalable Backend Development 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 4 de 4.
Quanto tempo leva a aula “GenStage e Fluxos com Contrapressão”?
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 Elixir & Phoenix: Scalable Backend Development?
Sim. Cada aula de Elixir & Phoenix: Scalable Backend Development 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
- Elixir Distribuído e Clustering
- Estratégias Avançadas de Supervisão
- Supervisores Dinâmicos e Registro
- GenStage e Fluxos com Contrapressão