Erlang-prosesser og meldinger
Forstå Erlangs grunnleggende samtidighetsprimitiv: prosessen. Lær hvordan prosesser kommuniserer gjennom asynkron meldingsutveksling, og bygg isolerte, lette samtidige enheter.
Erlang-prosesser og meldinger er en gratis leksjon i Erlang OTP: programmering av distribuerte og feiltolerante systemer på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Erlang OTP: programmering av distribuerte og feiltolerante systemer, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Erlang OTP: programmering av distribuerte og feiltolerante systemer inneholder totalt 4 leksjoner.
Erlangs kjerne: prosessen
Den grunnleggende enheten for samtidighet i Erlang er prosessen: et lite, uavhengig program som kjører sammen med andre og er langt lettere enn en tråd i operativsystemet.
Hvorfor Erlang-prosesser?
Erlang-prosesser er lette (millioner per maskin), isolerte (ingen delt hukommelse), samtidige og kommuniserer bare via asynkrone meldinger.
Opprette en ny prosess
Du oppretter en prosess med spawn ved å oppgi en modul, en funksjon og argumenter. Den returnerer en unik PID som identifiserer den nye prosessen.
-module(process_spawn).
-export([start/0, hello_world_process/0]).
hello_world_process() ->
io:format("Hello from a new Erlang process!~n").
start() ->
% Spawns a new process running hello_world_process/0
Pid = spawn(process_spawn, hello_world_process, []),
io:format("Spawned process with PID: ~p~n", [Pid]).Forstå prosess-ID-er (PID-er)
Alle prosesser får en unik PID – postadressen deres. Du trenger denne PID-en for å sende den en melding. Den ser slik ut: <0.80.0>.
Sende meldinger med «!»
Prosesser kommuniserer med meldinger, aldri med delt hukommelse. Send en melding med !-operatoren: Pid ! Message, der meldingen kan være et hvilket som helst Erlang-uttrykk.
-module(message_sender).
-export([start/0, receiver_process/0, sender_process/1]).
receiver_process() ->
io:format("Receiver process ~p started.~n", [self()]),
% This process will just print its PID for now.
% It doesn't receive messages in this version.
timer:sleep(1000). % Keep process alive for a moment
sender_process(ReceiverPid) ->
io:format("Sender process ~p sending message to ~p...~n", [self(), ReceiverPid]),
ReceiverPid ! {hello, "from sender"},
io:format("Message sent!~n").
start() ->
ReceiverPid = spawn(message_sender, receiver_process, []),
io:format("Receiver spawned with PID: ~p~n", [ReceiverPid]),
sender_process(ReceiverPid).Motta meldinger: «receive»
En prosess henter meldinger fra postkassen sin med receive, som mønstergjenkjenner hver melding og venter (eller får tidsavbrudd) til en samsvarende melding kommer.
-module(message_receiver).
-export([start/0, my_receiver/0, my_sender/1]).
my_receiver() ->
io:format("Receiver ~p waiting for messages...~n", [self()]),
receive
{hello, Msg} ->
io:format("Receiver ~p received: ~p~n", [self(), Msg]);
_AnyOtherMessage ->
io:format("Receiver ~p received an unexpected message: ~p~n", [self(), _AnyOtherMessage])
end,
io:format("Receiver ~p finished.~n", [self()]).
my_sender(ReceiverPid) ->
io:format("Sender ~p sending message to ~p.~n", [self(), ReceiverPid]),
ReceiverPid ! {hello, "World"},
io:format("Sender ~p sent message.~n", [self()]).
start() ->
ReceiverPid = spawn(message_receiver, my_receiver, []),
timer:sleep(100), % Give receiver time to start
my_sender(ReceiverPid).Et komplett meldingseksempel
Her er hele flyten i ett eksempel: spawn en server, klienten sender en forespørsel, og serveren mottar og svarer.
-module(full_message_example).
-export([start/0, server_loop/0, client_action/1]).
server_loop() ->
io:format("Server ~p started, waiting for requests...~n", [self()]),
receive
{request, ClientPid, Message} ->
io:format("Server ~p received request from ~p: ~p~n", [self(), ClientPid, Message]),
ClientPid ! {response, self(), "Got your message!"};
_Other ->
io:format("Server ~p received unexpected: ~p~n", [self(), _Other])
end.
client_action(ServerPid) ->
io:format("Client ~p sending request to server ~p...~n", [self(), ServerPid]),
ServerPid ! {request, self(), "Can you hear me?"},
receive
{response, ServerPid, Reply} ->
io:format("Client ~p received reply from ~p: ~p~n", [self(), ServerPid, Reply])
end.
start() ->
ServerPid = spawn(full_message_example, server_loop, []),
timer:sleep(100), % Give server time to start
client_action(ServerPid).Asynkron kommunikasjon
Erlang-meldinger er asynkrone: Avsenderen legger meldingen i postkassen og fortsetter, uten å blokkere mens den venter på mottakeren.
Prosessens postkasse
Hver prosess har en privat postkasse der innkommende meldinger legges i kø. En receive skanner den etter et mønstersamsvar, vanligvis i ankomstrekkefølge.
Finne din egen PID: `self()`
Den innebygde funksjonen self() returnerer PID-en til den gjeldende prosessen – nyttig når du skal sende meldinger til deg selv eller legge inn en svaradresse i en melding.
-module(self_example).
-export([start/0, print_self/0]).
print_self() ->
io:format("Hello, my PID is: ~p~n", [self()]).
start() ->
io:format("Parent process PID: ~p~n", [self()]),
spawn(self_example, print_self, []).
Kort sjekk: Meldingsflyt
Vurder følgende hendelsesforløp i Erlang:
- Prosess A oppretter prosess B.
- Prosess A sender en melding til prosess B.
- Prosess B mottar meldingen.
Hvilke av følgende påstander om denne samhandlingen er sanne?
Oppsummering: Prosesser og meldinger
Oppsummering: Prosesser kommuniserer med asynkrone meldinger – spawn returnerer en PID, ! sender, receive finner samsvar, hver prosess har en postkasse, og self() gir deg din egen PID.
Lær deg Erlang med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 12
- Leksjoner
- 48
Ofte stilte spørsmål
Er leksjonen «Erlang-prosesser og meldinger» gratis?
Ja – hele teksten i «Erlang-prosesser og meldinger» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Erlang OTP: programmering av distribuerte og feiltolerante systemer-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Erlang OTP: programmering av distribuerte og feiltolerante systemer inneholder totalt 4 leksjoner.
Hva lærer jeg i «Erlang-prosesser og meldinger»?
Forstå Erlangs grunnleggende samtidighetsprimitiv: prosessen. Lær hvordan prosesser kommuniserer gjennom asynkron meldingsutveksling, og bygg isolerte, lette samtidige enheter. Du øver på Erlang OTP: programmering av distribuerte og feiltolerante systemer med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Erlang OTP: programmering av distribuerte og feiltolerante systemer?
Ingen tidligere erfaring er nødvendig. Erlang OTP: programmering av distribuerte og feiltolerante systemer på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.
Hvor lang tid tar leksjonen «Erlang-prosesser og meldinger»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Erlang OTP: programmering av distribuerte og feiltolerante systemer-leksjonen?
Ja. Alle Erlang OTP: programmering av distribuerte og feiltolerante systemer-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Introduksjon til Erlang og VM
- Erlang-prosesser og meldinger
- Grunnleggende samtidighetsmønstre
- Mønstergjenkjenning og vakter