0Pricing
Erlang OTP: Distributed & Fault-Tolerant Systems Programming · Aula

Gerenciamento dinâmico de processos

Domine o início e a parada dinâmica de processos filhos dentro de supervisores, permitindo sistemas adaptáveis e eficientes no uso de recursos.

Gerenciamento dinâmico de processos é uma aula grátis de Erlang OTP: Distributed & Fault-Tolerant Systems Programming 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 Erlang OTP: Distributed & Fault-Tolerant Systems Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Erlang OTP: Distributed & Fault-Tolerant Systems Programming inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Dynamic Processes Overview

In Erlang, not all processes need to be started when your application first boots. Sometimes, you need processes that are created and destroyed on demand.

These are called dynamic processes, and they are crucial for building adaptable and resource-efficient systems. Think of them as temporary workers that supervisors can hire and fire as needed.

Why Dynamic Management?

Dynamic process management offers several key advantages:

  • Resource Efficiency: Only start processes when they are actually needed, saving memory and CPU.
  • Adaptability: Respond to varying loads by scaling up or down the number of workers.
  • On-Demand Tasks: Ideal for handling transient tasks like a new client connection, a file conversion request, or a single database query.

This contrasts with static children, which are always part of the supervisor's initial setup.

The `simple_one_for_one` Strategy

To manage dynamic children, supervisors often employ the simple_one_for_one restart strategy. This strategy is specifically designed for supervisors that will dynamically add children after startup.

  • It allows you to add children without pre-defining them in the supervisor's init/1 function.
  • Each dynamically added child is treated as a unique entity, even if they share the same underlying module.
  • If a dynamic child crashes, simple_one_for_one will restart only that child, not all of them.

Starting Dynamic Children

You start a dynamic child process using the supervisor:start_child/2 function. It takes two arguments:

  • SupRef: The name or PID of the supervisor.
  • ChildSpec: A map (or a list of tuples in older Erlang) describing the child process.

This function returns {ok, ChildPid} or an error if the child couldn't be started.

Dynamic Child Specification

A ChildSpec for a dynamic child is similar to a static one, but the id field is crucial for distinguishing instances. Here's a typical structure:

  • id: A unique atom or term to identify this specific child instance (e.g., client_123).
  • start: A tuple {Module, Function, Args} to call for starting the child (e.g., {gen_server, start_link, [{local, TaskId}, ?MODULE, [], []]}).
  • type: Either worker or supervisor.
  • restart: Often transient for dynamic workers, meaning they only restart if they crash unexpectedly, not if they exit normally.
  • shutdown: Timeout for graceful shutdown.

Code: Create Dynamic Workers

This example shows a supervisor starting two unique 'task' processes dynamically. Each task maintains its own count.

Run it to see how new processes are spawned and how you can interact with them individually.

-module(dynamic_start_example).
-behaviour(supervisor).

-export([start_link/0, init/1, start_task/1, call_task/2, run/0]).
-export([task_init/1, task_handle_call/3, task_terminate/2]).

% --- Supervisor part ---
start_link() ->
    supervisor:start_link({local, ?MODULE}, ?MODULE, []).

init([]) ->
    Strategy = {simple_one_for_one, 0, 1},
    Children = [],
    {ok, {Strategy, Children}}.

start_task(TaskId) ->
    io:format("Supervisor: Starting task ~p~n", [TaskId]),
    ChildSpec = #{
        id => TaskId,
        start => {gen_server, start_link, [{local, TaskId}, ?MODULE, [], []]},
        type => worker,
        restart => transient,
        shutdown => 5000
    },
    supervisor:start_child(?MODULE, ChildSpec).

call_task(TaskId, Message) ->
    gen_server:call(TaskId, Message).

% --- Worker part (this module acts as a gen_server for the tasks) ---
task_init([]) ->
    io:format("Task ~p: Initializing with count 0~n", [self()]),
    {ok, 0}. % Initial state for the task

task_handle_call(get_count, _From, State) ->
    io:format("Task ~p: Getting count ~p~n", [self(), State]),
    {reply, State, State}.
task_handle_call({increment, Value}, _From, State) ->
    NewState = State + Value,
    io:format("Task ~p: Incrementing by ~p to ~p~n", [self(), Value, NewState]),
    {reply, NewState, NewState}.

task_terminate(_Reason, State) ->
    io:format("Task ~p: Terminating with final state ~p~n", [self(), State]),
    ok.

% --- Entry point for runnable example ---
run() ->
    io:format("~n--- Starting Dynamic Task Example ---~n"),
    {ok, SupPid} = dynamic_start_example:start_link(),
    io:format("Supervisor started: ~p~n", [SupPid]),

    io:format("~nStarting Task 'task_alpha':~n"),
    dynamic_start_example:start_task(task_alpha),
    timer:sleep(100), % Give it a moment to start

    Count1 = dynamic_start_example:call_task(task_alpha, get_count),
    io:format("Task 'task_alpha' count: ~p~n", [Count1]),

    dynamic_start_example:call_task(task_alpha, {increment, 7}),
    Count2 = dynamic_start_example:call_task(task_alpha, get_count),
    io:format("Task 'task_alpha' count after increment: ~p~n", [Count2]),

    io:format("~nStarting Task 'task_beta':~n"),
    dynamic_start_example:start_task(task_beta),
    timer:sleep(100),

    Count3 = dynamic_start_example:call_task(task_beta, get_count),
    io:format("Task 'task_beta' count: ~p~n", [Count3]),

    dynamic_start_example:call_task(task_beta, {increment, 12}),
    Count4 = dynamic_start_example:call_task(task_beta, get_count),
    io:format("Task 'task_beta' count after increment: ~p~n", [Count4]),

    % In a real app, you'd stop the supervisor or individual tasks here.
    % For this example, we'll let them run.
    io:format("--- Dynamic Task Start Demo Finished ---~n"),
    ok.

Terminating Dynamic Children

Just as you can start processes dynamically, you can also stop them. The supervisor:terminate_child/2 function is used for this.

  • It takes the SupRef and the ChildId (the id from the child specification) as arguments.
  • The supervisor will send an exit signal to the child, initiating a graceful shutdown.
  • Once terminated, the child is removed from the supervisor's list, freeing up resources.

This is crucial for managing resources and ensuring processes don't linger unnecessarily.

Code: Terminate Dynamic Workers

This example demonstrates starting a task, interacting with it, and then gracefully stopping it using terminate_child/2. Notice the output when the task terminates.

-module(dynamic_stop_example).
-behaviour(supervisor).

-export([start_link/0, init/1, start_task/1, call_task/2, stop_task/1, run/0]).
-export([task_init/1, task_handle_call/3, task_terminate/2]).

% --- Supervisor part ---
start_link() ->
    supervisor:start_link({local, ?MODULE}, ?MODULE, []).

init([]) ->
    Strategy = {simple_one_for_one, 0, 1},
    Children = [],
    {ok, {Strategy, Children}}.

start_task(TaskId) ->
    io:format("Supervisor: Starting task ~p~n", [TaskId]),
    ChildSpec = #{
        id => TaskId,
        start => {gen_server, start_link, [{local, TaskId}, ?MODULE, [], []]},
        type => worker,
        restart => transient,
        shutdown => 5000
    },
    supervisor:start_child(?MODULE, ChildSpec).

call_task(TaskId, Message) ->
    gen_server:call(TaskId, Message).

stop_task(TaskId) ->
    io:format("Supervisor: Stopping task ~p~n", [TaskId]),
    supervisor:terminate_child(?MODULE, TaskId).

% --- Worker part (this module acts as a gen_server for the tasks) ---
task_init([]) ->
    io:format("Task ~p: Initializing with count 0~n", [self()]),
    {ok, 0}.

task_handle_call(get_count, _From, State) ->
    io:format("Task ~p: Getting count ~p~n", [self(), State]),
    {reply, State, State}.
task_handle_call({increment, Value}, _From, State) ->
    NewState = State + Value,
    io:format("Task ~p: Incrementing by ~p to ~p~n", [self(), Value, NewState]),
    {reply, NewState, NewState}.

task_terminate(_Reason, State) ->
    io:format("Task ~p: Terminating with final state ~p~n", [self(), State]),
    ok.

% --- Entry point for runnable example ---
run() ->
    io:format("~n--- Terminating Dynamic Task Example ---~n"),
    {ok, SupPid} = dynamic_stop_example:start_link(),
    io:format("Supervisor started: ~p~n", [SupPid]),

    io:format("~nStarting Task 'temp_task':~n"),
    dynamic_stop_example:start_task(temp_task),
    timer:sleep(100),

    dynamic_stop_example:call_task(temp_task, {increment, 100}),
    Count = dynamic_stop_example:call_task(temp_task, get_count),
    io:format("Task 'temp_task' current count: ~p~n", [Count]),

    io:format("~nStopping Task 'temp_task':~n"),
    dynamic_stop_example:stop_task(temp_task),
    timer:sleep(100), % Give it a moment to terminate

    io:format("~nAttempting to call 'temp_task' after termination (will fail):~n"),
    CatchResult = try dynamic_stop_example:call_task(temp_task, get_count) of
                      Result -> Result
                  catch
                      error:Reason -> {error, Reason}
                  end,
    io:format("Call result after stop: ~p~n", [CatchResult]),

    supervisor:stop(SupPid), % Clean up the supervisor
    io:format("Supervisor stopped.~n"),
    io:format("--- Dynamic Task Stop Demo Finished ---~n"),
    ok.

Practical Use Cases

Dynamic process management is a powerful tool in Erlang. Here are some common scenarios where it shines:

  • Web Servers: Spawning a new process for each incoming client connection.
  • Connection Pools: Managing a pool of database connections, creating new ones as needed.
  • Batch Processors: Starting worker processes to handle items from a queue.
  • User Sessions: Managing individual user sessions in a multi-user application.

It allows your system to adapt to varying loads and efficiently manage transient resources.

Quick Check

You've learned about starting and stopping dynamic child processes. Let's test your understanding.

Recap: Dynamic Processes

We've explored dynamic process management, a key technique for building adaptable Erlang systems:

  • Dynamic processes are created and destroyed on demand, saving resources.
  • The simple_one_for_one strategy is typically used by supervisors managing dynamic children.
  • supervisor:start_child/2 is used to add new processes, providing a unique child specification for each.
  • supervisor:terminate_child/2 ensures graceful shutdown and removal of dynamic processes.

Mastering this allows your applications to efficiently scale and respond to changing demands.

Perguntas Frequentes

A aula “Gerenciamento dinâmico de processos” é grátis?

Sim — o texto completo de “Gerenciamento dinâmico de processos” é 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 Erlang OTP: Distributed & Fault-Tolerant Systems Programming, atualize para CoddyKit PRO. O curso de Erlang OTP: Distributed & Fault-Tolerant Systems Programming inclui 4 aulas no total.

O que vou aprender em “Gerenciamento dinâmico de processos”?

Domine o início e a parada dinâmica de processos filhos dentro de supervisores, permitindo sistemas adaptáveis e eficientes no uso de recursos. Você pratica Erlang OTP: Distributed & Fault-Tolerant Systems Programming 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 Erlang OTP: Distributed & Fault-Tolerant Systems Programming?

Nenhuma experiência prévia é necessária. Erlang OTP: Distributed & Fault-Tolerant Systems Programming 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 “Gerenciamento dinâmico de processos”?

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 Erlang OTP: Distributed & Fault-Tolerant Systems Programming?

Sim. Cada aula de Erlang OTP: Distributed & Fault-Tolerant Systems Programming 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. Árvores de supervisão complexas
  2. Gerenciamento dinâmico de processos
  3. Estratégias avançadas de reinicialização
  4. Pontes de Supervisores e Hierarquias de Processos Mistas
← Voltar para Erlang OTP: Distributed & Fault-Tolerant Systems Programming