Linkit ja monitorit selitettyinä
Erotatte linkit ja monitorit toisistaan sekä ymmärrätte niiden roolit prosessien valvonnassa ja lopetussignaalien välittämisessä.
Linkit ja monitorit selitettyinä on ilmainen Erlang OTP: hajautettujen ja vikasietoisten järjestelmien ohjelmointi-oppitunti CoddyKitissä. Tämä on oppitunti 1/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Erlang OTP: hajautettujen ja vikasietoisten järjestelmien ohjelmointi-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Erlang OTP: hajautettujen ja vikasietoisten järjestelmien ohjelmointi-kurssilla on yhteensä 4 oppituntia.
Johdanto prosessien vikoihin
Erlang-prosessit on suunniteltu eristetyiksi. Mutta mitä tapahtuu, kun yksi prosessi kaatuu? Miten muut prosessit saavat siitä tiedon, ja miten ne voivat reagoida?
Vikojen etenemisen ymmärtäminen on olennaista vikasietoisten Erlang-järjestelmien rakentamisessa. Tässä oppitunnissa esitellään kaksi keskeistä mekanismia: linkit ja monitorit.
Prosessien linkittäminen
Linkki on kaksisuuntainen yhteys kahden Erlang-prosessin välillä. Se on kuin kädestä pitäminen: jos yksi prosessi lopetetaan (päättyy), se lähettää lopetussignaalin kaikille linkitetyille prosesseille.
- Linkit luodaan funktioilla
spawn_link/1,2,3,4. - Jos toiseen prosessiin linkitetty prosessi päättyy normaalisti, lopetussignaali on
normal. - Jos prosessi päättyy virheeseen, lopetussignaali sisältää kaatumisen syyn.
Linkittäminen: kaatumisen oletusarvoinen eteneminen
Oletusarvoisesti prosessi, joka vastaanottaa linkitetyltä prosessilta muun kuin normal-lopetussignaalin, päättyy myös saman syyn vuoksi. Tätä kutsutaan kaatumisen etenemiseksi.
Kokeilkaa tämän esimerkin suorittamista. Lapsiprosessi kaatuu, ja koska isäntäprosessi on linkitetty siihen, myös isäntäprosessi kaatuu!
-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 errorLopetussignaalien sieppaaminen: vikojen käsittely
Vaikka kaatumisen eteneminen on hyödyllistä yksinkertaisissa ”kaikki tai ei mitään” -tilanteissa, prosessin halutaan usein käsittelevän linkitetyn prosessin kaatumisen sen sijaan, että se vain kuolisi sen mukana. Tällöin lopetussignaalien sieppaamisesta on hyötyä.
Asettamalla process_flag(trap_exit, true) prosessi muuntaa linkitetyiltä prosesseilta saapuvat lopetussignaalit viesteiksi {'EXIT', Pid, Reason}, jotka se voi vastaanottaa ja käsitellä.
Lopetussignaalien sieppaaminen koodissa
Tässä isäntäprosessi sieppaa lopetussignaalit. Kun lapsiprosessi kaatuu, isäntäprosessi vastaanottaa 'EXIT'-viestin kaatumatta itse. Tämä on olennaista valvojien rakentamisessa!
-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).Prosessien monitorointi
Monitori on yksisuuntainen yhteys. Sen avulla yksi prosessi voi seurata toisen prosessin päättymistä vaikuttamatta oman elinkaarensa kulkuun.
- Monitorit luodaan käyttämällä
erlang:monitor(process, Pid)-kutsua. - Jos seurattava prosessi päättyy, monitoroiva prosessi vastaanottaa viestin
{'DOWN', MonitorRef, process, Pid, Reason}. - Monitoroiva prosessi EI kaadu oletusarvoisesti, vaikka se ei käsittelisi poistumissignaaleja.
Monitorointi käytännössä: kaatuminen ei leviä
Tässä esimerkissä isäntäprosessi monitoroi lapsiprosessia. Kun lapsiprosessi kaatuu, isäntäprosessi vastaanottaa 'DOWN'-viestin, mutta pysyy itse aktiivisena eikä kaadu.
-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).Linkkien ja monitorien keskeiset erot
Linkkien ja monitorien välinen valinta riippuu vikasietoisuusstrategiastanne. Tässä on lyhyt vertailu:
- Linkit: Kaksisuuntaisia, välittävät kaatumiset oletusarvoisesti, ja niitä käytetään tiiviisti kytkeytyneissä prosesseissa (esimerkiksi valvontapuun isäntä- ja lapsiprosesseissa).
- Monitorit: Yksisuuntaisia, lähettävät vain
'DOWN'-viestejä, eivät välitä kaatumisia oletusarvoisesti, ja niitä käytetään löyhästi kytkeytyneissä prosesseissa tai tilapäiseen seurantaan. - Linkkejä käytetään, kun prosessien halutaan ”elävän tai kuolevan yhdessä” (ellei poistumissignaaleja käsitellä). Monitorit sopivat tilanteisiin, joissa halutaan vain ”tietää, jos prosessi kuoli”.
Milloin kumpaakin käytetään?
Linkit ovat Erlangin valvontapuiden perusta: valvoja on linkitetty lapsiprosesseihinsa ja käsittelee poistumissignaaleja käynnistääkseen ne uudelleen. Monitoreita käytetään usein esimerkiksi tarkistamaan, onko etäpalvelu edelleen aktiivinen, tai resurssien siivoamiseen prosessin päätyttyä.
Voitte myös luoda linkin käyttämällä erlang:link(Pid)-kutsua ja poistaa sen käyttämällä erlang:unlink(Pid)-kutsua. Vastaavasti monitorin voi poistaa kutsulla erlang:demonitor(MonitorRef).
Kysymys: linkki vai monitori?
Kuvitelkaa rakentavanne Erlang-sovellusta. Missä seuraavista tilanteista monitorin käyttäminen olisi sopivampaa kuin linkin käyttäminen?
Kertaus: linkit ja monitorit
Tässä oppitunnissa olette tutustuneet Erlangin keskeisiin vikasietoisuusmekanismeihin:
- Linkit: Kaksisuuntaisia yhteyksiä, jotka välittävät poistumissignaaleja ja aiheuttavat kaatumisen oletusarvoisesti myös toisessa prosessissa.
- Poistumissignaalien käsittely: Mekanismi, jonka avulla linkitetyt prosessit voivat muuntaa poistumissignaalit viesteiksi ja käsitellä virheitä.
- Monitorit: Yksisuuntaisia yhteyksiä, jotka lähettävät
'DOWN'-viestin monitoroitavan prosessin päättyessä aiheuttamatta oletusarvoisesti kaatumista.
Nämä mekanismit ovat olennaisia vankkojen ja itsestään palautuvien Erlang-sovellusten rakentamisessa sekä OTP:n valvontapuiden perustana.
Opi Erlang tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 12
- Oppitunnit
- 48
Usein kysytyt kysymykset
Onko oppitunti ”Linkit ja monitorit selitettyinä” ilmainen?
Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Erlang OTP: hajautettujen ja vikasietoisten järjestelmien ohjelmointi-oppimispolun 3 oppituntia, myös oppitunnin “Linkit ja monitorit selitettyinä”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Erlang OTP: hajautettujen ja vikasietoisten järjestelmien ohjelmointi-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”Linkit ja monitorit selitettyinä”?
Erotatte linkit ja monitorit toisistaan sekä ymmärrätte niiden roolit prosessien valvonnassa ja lopetussignaalien välittämisessä. Harjoittelet Erlang OTP: hajautettujen ja vikasietoisten järjestelmien ohjelmointi-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni Erlang OTP: hajautettujen ja vikasietoisten järjestelmien ohjelmointi-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin Erlang OTP: hajautettujen ja vikasietoisten järjestelmien ohjelmointi-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/4.
Kuinka kauan ”Linkit ja monitorit selitettyinä”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä Erlang OTP: hajautettujen ja vikasietoisten järjestelmien ohjelmointi-oppitunnilla?
Kyllä. Jokainen Erlang OTP: hajautettujen ja vikasietoisten järjestelmien ohjelmointi-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Linkit ja monitorit selitettyinä
- Vankka virheenkäsittely
- Crash-first-suunnittelu
- Let-it-crash-filosofia