Förklarat: länkar och monitors
Lär er skilja mellan länkar och monitors och förstå deras roller i processövervakning och spridning av exitsignaler.
Förklarat: länkar och monitors är en gratis lektion i Erlang OTP: Programmering av distribuerade och feltoleranta system på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Erlang OTP: Programmering av distribuerade och feltoleranta system, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Erlang OTP: Programmering av distribuerade och feltoleranta system innehåller totalt 4 lektioner.
Introduktion till processfel
Erlang-processer är utformade för att vara isolerade. Men vad händer när en process kraschar? Hur får andra processer reda på det, och hur kan de reagera?
Att förstå hur fel fortplantar sig är avgörande för att bygga feltåliga system i Erlang. Den här lektionen introducerar två grundläggande mekanismer: länkar och monitorer.
Så fungerar processlänkning
En länk är en dubbelriktad anslutning mellan två Erlang-processer. Det är som att hålla varandra i handen: om den ena processen avslutas skickar den en avslutningssignal till alla länkade processer.
- Länkar skapas med
spawn_link/1,2,3,4. - Om en process som är länkad till en annan process avslutas normalt är avslutningssignalen
normal. - Om den avslutas på grund av ett fel innehåller avslutningssignalen orsaken till kraschen.
Länkning: standardmässig kraschfortplantning
Som standard avslutas en process också med samma orsak om den tar emot en avslutningssignal (annan än normal) från en länkad process. Detta kallas kraschfortplantning.
Prova att köra det här exemplet. Barnprocessen kraschar, och eftersom föräldraprocessen är länkad till den kraschar även föräldraprocessen!
-module(link_example).
-export([start/0]).
start() ->
ParentPid = self(),
io:format("Parent (~p) starting...~n", [ParentPid]),
ChildPid = spawn_link(fun() -> child_process(ParentPid) end),
io:format("Parent (~p) linked to child (~p).~n", [ParentPid, ChildPid]),
timer:sleep(5000), % Wait for child to crash
io:format("Parent (~p) still alive (this won't print if it crashed).~n", [ParentPid]).
child_process(ParentPid) ->
io:format("Child (~p) started, linked to Parent (~p).~n", [self(), ParentPid]),
timer:sleep(1000), % Simulate some work
io:format("Child (~p) crashing now!~n", [self()]),
exit(i_crashed). % Child exits with an errorFånga avslutningar: hantera fel
Kraschfortplantning är användbart i enkla scenarier där allt ska lyckas eller misslyckas tillsammans, men ofta vill ni att en process ska hantera en länkad process krasch i stället för att dö med den. Det är här fångst av avslutningar kommer in.
Genom att ange process_flag(trap_exit, true) omvandlar en process inkommande avslutningssignaler från länkade processer till meddelanden av typen {'EXIT', Pid, Reason}, som den sedan kan ta emot och bearbeta.
Fånga avslutningar i kod
Här fångar föräldraprocessen avslutningar. När barnprocessen kraschar tar föräldraprocessen emot ett 'EXIT'-meddelande i stället för att själv krascha. Detta är grundläggande när man bygger supervisors!
-module(trap_exit_example).
-export([start/0]).
start() ->
ParentPid = self(),
io:format("Parent (~p) starting and trapping exits...~n", [ParentPid]),
process_flag(trap_exit, true),
ChildPid = spawn_link(fun() -> child_process(ParentPid) end),
io:format("Parent (~p) linked to child (~p).~n", [ParentPid, ChildPid]),
receive
{'EXIT', ChildPid, Reason} ->
io:format("Parent (~p) caught exit from child (~p) with reason: ~p~n", [ParentPid, ChildPid, Reason]);
_ ->
io:format("Parent (~p) received unexpected message.~n", [ParentPid])
after 5000 ->
io:format("Parent (~p) timed out waiting for exit message.~n", [ParentPid])
end.
child_process(ParentPid) ->
io:format("Child (~p) started, linked to Parent (~p).~n", [self(), ParentPid]),
timer:sleep(1000),
io:format("Child (~p) crashing now!~n", [self()]),
exit(i_crashed_trapped).Så fungerar processövervakning
En monitor är en enkelriktad anslutning. Den gör det möjligt för en process att observera en annan process tills den avslutas, utan att påverka den egna livscykeln.
- Monitorer skapas med
erlang:monitor(process, Pid). - Om den övervakade processen avslutas tar den övervakande processen emot ett
{'DOWN', MonitorRef, process, Pid, Reason}-meddelande. - Den övervakande processen kraschar INTE som standard, även om den inte fångar exitsignaler.
Monitorering i praktiken: ingen kraschpropagering
I det här exemplet övervakar föräldern den underordnade processen. När den underordnade processen kraschar tar föräldern emot ett 'DOWN'-meddelande, men föräldern förblir aktiv och kraschar inte själv.
-module(monitor_example).
-export([start/0]).
start() ->
ParentPid = self(),
io:format("Parent (~p) starting...~n", [ParentPid]),
ChildPid = spawn(fun() -> child_process() end),
MonitorRef = erlang:monitor(process, ChildPid),
io:format("Parent (~p) monitoring child (~p). Monitor ref: ~p~n", [ParentPid, ChildPid, MonitorRef]),
receive
{'DOWN', MonitorRef, process, ChildPid, Reason} ->
io:format("Parent (~p) received DOWN message for child (~p) with reason: ~p~n", [ParentPid, ChildPid, Reason]);
_ ->
io:format("Parent (~p) received unexpected message.~n", [ParentPid])
after 5000 ->
io:format("Parent (~p) timed out waiting for DOWN message.~n", [ParentPid])
end,
io:format("Parent (~p) finished, still alive!~n", [ParentPid]).
child_process() ->
io:format("Child (~p) started, will crash soon.~n", [self()]),
timer:sleep(1000),
io:format("Child (~p) crashing now!~n", [self()]),
exit(i_crashed_monitored).Länkar kontra monitorer: viktiga skillnader
Vilket ni väljer mellan länkar och monitorer beror på er strategi för feltolerans. Här är en snabb jämförelse:
- Länkar: Dubbelriktade, propagerar krascher som standard och används för tätt kopplade processer (till exempel förälder och underordnade i ett övervakningsträd).
- Monitorer: Enkelriktade, skickar endast
'DOWN'-meddelanden, propagerar inte krascher som standard och används för löst kopplade processer eller tillfällig övervakning. - Länkar används när ni vill att processer ska ”leva eller dö tillsammans” (såvida ni inte fångar exitsignaler). Monitorer används när ni bara vill ”veta om processen dog”.
När ska ni använda vad?
Länkar utgör grunden för Erlangs övervakningsträd, där en supervisor är länkad till sina underordnade processer och fångar exitsignaler för att kunna starta om dem. Monitorer används ofta när ni till exempel vill kontrollera om en fjärrtjänst fortfarande är aktiv eller frigöra resurser efter att en process har avslutats.
Ni kan också skapa en länk med erlang:link(Pid) och ta bort den med erlang:unlink(Pid). På motsvarande sätt kan ni ta bort en monitor med erlang:demonitor(MonitorRef).
Fråga: länk eller monitor?
Föreställ er att ni bygger en Erlang-applikation. I vilket av följande scenarier skulle det vara lämpligare att använda en monitor än en länk?
Sammanfattning: länkar och monitorer
I den här lektionen har ni lärt er om Erlangs grundläggande primitiver för feltolerans:
- Länkar: Dubbelriktade anslutningar som propagerar exitsignaler och därmed som standard orsakar kraschpropagering.
- Fånga exitsignaler: En mekanism som gör att länkade processer kan omvandla exitsignaler till meddelanden, så att de kan hantera fel.
- Monitorer: Enkelriktade anslutningar som skickar
'DOWN'-meddelanden när den övervakade processen avslutas, utan kraschpropagering som standard.
Dessa mekanismer är grundläggande för att bygga robusta och självläkande Erlang-applikationer och utgör basen för OTP:s övervakningsträd.
Lär dig Erlang med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Förklarat: länkar och monitors” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Erlang OTP: Programmering av distribuerade och feltoleranta system, inklusive ”Förklarat: länkar och monitors”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Erlang OTP: Programmering av distribuerade och feltoleranta system innehåller totalt 4 lektioner.
Vad lär jag mig i ”Förklarat: länkar och monitors”?
Lär er skilja mellan länkar och monitors och förstå deras roller i processövervakning och spridning av exitsignaler. Ni övar på Erlang OTP: Programmering av distribuerade och feltoleranta system med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Erlang OTP: Programmering av distribuerade och feltoleranta system?
Du behöver inga förkunskaper. Utbildningen i Erlang OTP: Programmering av distribuerade och feltoleranta system på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Förklarat: länkar och monitors”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Erlang OTP: Programmering av distribuerade och feltoleranta system-lektionen?
Ja. Varje Erlang OTP: Programmering av distribuerade och feltoleranta system-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Förklarat: länkar och monitors
- Robust felhantering
- Designa enligt principen crash-first
- Filosofin ”let-it-crash”