PricingLoginStart free
Erlang OTP: Programmering af distribuerede og fejltolerante systemer · Lektion

Komplekse supervisionstræer

Design og implementér komplekse, indlejrede supervisionhierarkier, så afhængigheder og fejlgrænser håndteres effektivt.

Lektion 1 af 411 trin

Komplekse supervisionstræer er en gratis Erlang OTP: Programmering af distribuerede og fejltolerante systemer-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Erlang OTP: Programmering af distribuerede og fejltolerante systemer, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Erlang OTP: Programmering af distribuerede og fejltolerante systemer-kurset indeholder 4 lektioner i alt.

Supervisortræer: det grundlæggende

I Erlang er supervisorer særlige processer, der overvåger andre processer, som kaldes børn. Hvis en barneproces går ned, kan supervisoren genstarte den, så fejltolerancen bevares.

Et supervisionstræ opstår, når en supervisor selv bliver barn af en anden supervisor. Det skaber et hierarki, der minder om et organisationsdiagram.

Hvorfor komplekse træer?

Efterhånden som applikationer vokser, er én supervisor ikke nok. Komplekse supervisionstræer giver os mulighed for at:

  • Håndtere afhængigheder: Gruppere relaterede processer, så de starter og stopper sammen.
  • Isolere fejl: Et nedbrud i én del af træet behøver ikke at få uafhængige dele til at gå ned.
  • Forbedre modulariteten: Hver supervisor kan være ansvarlig for et bestemt undersystem, så applikationen bliver lettere at forstå og vedligeholde.

Bernespecifikation: arbejder kontra supervisor

Hver proces, som en supervisor administrerer, defineres af en barnespecifikation. En barnespecifikation fortæller supervisoren, hvordan barneprocessen skal startes, genstartes og lukkes ned.

Det er vigtigt, at et barn kan være af to typer:

  • worker: En almindelig proces (f.eks. en gen_server), der udfører applikationslogik.
  • supervisor: En anden supervisorproces, der danner et indlejret niveau i træet.

Arbejderen: my_worker_module

Lad os begynde med en enkel arbejderproces. Denne gen_server bliver bladnoden i vores supervisionstræ. Den udskriver blot beskeder, når den starter eller modtager kald.

-module(my_worker_module).
-behaviour(gen_server).

-export([start_link/1, init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).

start_link(Id) ->
    gen_server:start_link(?MODULE, Id, []).

init(Id) ->
    io:format("Worker ~p starting...~n", [Id]),
    {ok, Id}.

handle_call(Req, _From, State) ->
    io:format("Worker ~p received call: ~p~n", [State, Req]),
    {reply, ok, State}.

handle_cast(Msg, State) ->
    io:format("Worker ~p received cast: ~p~n", [State, Msg]),
    {noreply, State}.

handle_info(Msg, State) ->
    io:format("Worker ~p received info: ~p~n", [State, Msg]),
    {noreply, State}.

terminate(_Reason, State) ->
    io:format("Worker ~p terminating...~n", [State]).

code_change(_OldVsn, State, _Extra) ->
    {ok, State}.

Den indlejrede supervisor: my_nested_sup

Denne supervisor administrerer vores processer i my_worker_module. Den definerer to arbejdere, »WorkerA« og »WorkerB«, som hver har en lidt anderledes genstartsstrategi.

Bemærk, hvordan dens child_specs definerer type => worker.

-module(my_nested_sup).
-behaviour(supervisor).

-export([start_link/0, init/1]).

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

init([]) ->
    SupFlags = #{
        strategy => one_for_one,
        intensity => 10,
        period => 1
    },
    ChildSpecs = [
        #{
            id => worker_A,
            start => {my_worker_module, start_link, ["WorkerA"]},
            type => worker,
            restart => permanent,
            shutdown => 5000,
            modules => [my_worker_module]
        },
        #{
            id => worker_B,
            start => {my_worker_module, start_link, ["WorkerB"]},
            type => worker,
            restart => transient,
            shutdown => 2000,
            modules => [my_worker_module]
        }
    ],
    {ok, {SupFlags, ChildSpecs}}.

Supervisoren på øverste niveau: my_app_sup

Dette er roden i vores komplekse træ. Den superviserer my_nested_sup. Bemærk, at dens child_spec for my_nested_sup har type => supervisor. Sådan bygger du indlejrede træer!

-module(my_app_sup).
-behaviour(supervisor).

-export([start_link/0, init/1]).

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

init([]) ->
    SupFlags = #{
        strategy => one_for_one,
        intensity => 10,
        period => 1
    },
    ChildSpecs = [
        #{
            id => my_nested_sup_child,
            start => {my_nested_sup, start_link, []},
            type => supervisor,
            restart => permanent,
            shutdown => infinity,
            modules => [my_nested_sup]
        }
    ],
    {ok, {SupFlags, ChildSpecs}}.

Kørsel af det komplekse træ

Hvis du vil se vores træ i funktion, skal du kompilere alle tre moduler (my_worker_module.erl, my_nested_sup.erl, my_app_sup.erl) og derefter starte supervisoren på øverste niveau. Du vil se arbejderne starte!

Du kan bruge supervisor:which_children(PidOrName) til at undersøge træet.

% In the Erlang shell:

c(my_worker_module).
c(my_nested_sup).
c(my_app_sup).

{ok, MySupPid} = my_app_sup:start_link().

% Check the children of the top-level supervisor:
supervisor:which_children(MySupPid).

% Find the nested supervisor's PID:
{_, NestedSupPid, _, _} = lists:keyfind(my_nested_sup_child, 1, supervisor:which_children(MySupPid)).

% Check the children of the nested supervisor:
supervisor:which_children(NestedSupPid).

Visualisering af hierarkiet

Vores komplekse supervisionstræ ser sådan ud:

  • my_app_sup (supervisor på øverste niveau)
    • superviserer my_nested_sup (en barnesupervisor)
      • superviserer worker_A (en arbejderproces)
      • superviserer worker_B (en arbejderproces)

Denne struktur sikrer, at hvis worker_A går ned, er det kun my_nested_sup, der håndterer det. Hvis my_nested_sup selv går ned, genstarter my_app_sup den og bringer worker_A og worker_B tilbage til live.

Fordele ved komplekse træer

Komplekse supervisionstræer er en hjørnesten i opbygningen af robuste Erlang-applikationer. De giver:

  • Fejlisolation: Fejl begrænses til bestemte grene.
  • Logisk gruppering: Komponenter med relaterede funktioner superviseres samlet.
  • Klare ansvarsområder: Hver supervisor har et veldefineret sæt processer, som den er ansvarlig for.
  • Skalerbarhed: Det er lettere at tilføje eller fjerne undersystemer uden at forstyrre hele applikationen.

Hurtigtjek: supervisionstræer

Hvilke af følgende er vigtige fordele ved at bruge komplekse (indlejrede) supervisionstræer i Erlang?

Besvar den i den interaktive lektion

Opsummering: kompleks supervision

I dag har vi undersøgt komplekse supervisionstræer i Erlang. Vi har lært, at supervisorer kan administrere andre supervisorer og dermed skabe indlejrede hierarkier. Dette effektive mønster giver robust fejltolerance ved at isolere fejl, håndtere afhængigheder og forbedre modulariteten i dine applikationer. Ved at definere barnespecifikationer med type => supervisor kan du bygge indviklede og modstandsdygtige Erlang-systemer.

Gratis at komme i gang

Lær Erlang med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
12
Lektioner
48
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Komplekse supervisionstræer” gratis?

Ja — alle 3 lektioner i læringssporet Erlang OTP: Programmering af distribuerede og fejltolerante systemer, inklusive “Komplekse supervisionstræer”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Erlang OTP: Programmering af distribuerede og fejltolerante systemer-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Komplekse supervisionstræer”?

Design og implementér komplekse, indlejrede supervisionhierarkier, så afhængigheder og fejlgrænser håndteres effektivt. Du øver dig i Erlang OTP: Programmering af distribuerede og fejltolerante systemer med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Erlang OTP: Programmering af distribuerede og fejltolerante systemer?

Der kræves ingen tidligere erfaring. Erlang OTP: Programmering af distribuerede og fejltolerante systemer på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Komplekse supervisionstræer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Erlang OTP: Programmering af distribuerede og fejltolerante systemer-lektion?

Ja. Alle Erlang OTP: Programmering af distribuerede og fejltolerante systemer-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Komplekse supervisionstræer
  2. Dynamisk proceshåndtering
  3. Avancerede genstartstrategier
  4. Supervisor bridges og blandede proceshierarkier
← Tilbage til Erlang OTP: Programmering af distribuerede og fejltolerante systemer