Erlang-processer og messaging
Forstå Erlangs centrale primitiver til samtidighed: processen. Lær, hvordan processer kommunikerer via asynkron meddelelsesudveksling, og opbyg isolerede, lette samtidige enheder.
Erlang-processer og messaging er en gratis Erlang OTP: Programmering af distribuerede og fejltolerante systemer-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig 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.
Erlangs kerne: Processen
Den grundlæggende enhed for samtidighed i Erlang er processen: et lille, uafhængigt program, der kører sammen med andre og er langt mindre end en tråd i operativsystemet.
Hvorfor Erlang-processer?
Erlang-processer er lette (millioner pr. maskine), isolerede (ingen delt hukommelse), samtidige og kommunikerer kun via asynkrone beskeder.
Opret en ny proces
Du opretter en proces med spawn ved at angive et modul, en funktion og argumenter. Den returnerer en unik PID, som identificerer den nye proces.
-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å proces-id'er (PID'er)
Hver proces får en unik PID – dens postadresse. Du skal bruge denne PID for at sende den en besked; den ser f.eks. sådan ud: <0.80.0>.
Send beskeder med »!«
Processer kommunikerer via beskeder, aldrig via delt hukommelse. Send en besked med !-operatoren: Pid ! Message, hvor beskeden kan være et hvilket som helst Erlang-udtryk.
-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).Modtag beskeder: »receive«
En proces henter beskeder fra sin postkasse med receive, som matcher hver besked med mønstre og venter (eller får timeout), indtil der kommer et match.
-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 komplet eksempel på beskedudveksling
Her er hele forløbet i ét eksempel: spawn en server, klienten sender en forespørgsel, og serveren modtager 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 kommunikation
Erlang-beskeder er asynkrone: Afsenderen lægger beskeden i postkassen og fortsætter uden at blokere og vente på modtageren.
Processens postkasse
Hver proces har en privat postkasse, hvor indgående beskeder sættes i kø. En receive gennemgår den for et mønstermatch, normalt i den rækkefølge beskederne ankom.
Kend din egen PID: `self()`
Den indbyggede funktion self() returnerer PID'en for den aktuelle proces – praktisk, når du vil sende en besked til dig selv eller indlejre en svaradresse i en besked.
-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, []).
Hurtigt tjek: Beskedforløb
Overvej følgende hændelsesforløb i Erlang:
- Proces A opretter Proces B.
- Proces A sender en besked til Proces B.
- Proces B modtager beskeden.
Hvilke af følgende udsagn om denne interaktion er sande?
Opsummering: Processer og beskeder
Opsummering: Processer kommunikerer via asynkrone beskeder – spawn returnerer en PID, ! sender, receive matcher, hver proces har en postkasse, og self() giver dig din egen PID.
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
Ofte stillede spørgsmål
Er lektionen “Erlang-processer og messaging” gratis?
Ja — hele teksten til “Erlang-processer og messaging” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Erlang OTP: Programmering af distribuerede og fejltolerante systemer-kurset, skal du opgradere til CoddyKit PRO. Erlang OTP: Programmering af distribuerede og fejltolerante systemer-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Erlang-processer og messaging”?
Forstå Erlangs centrale primitiver til samtidighed: processen. Lær, hvordan processer kommunikerer via asynkron meddelelsesudveksling, og opbyg isolerede, lette samtidige enheder. 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 2 af 4.
Hvor lang tid tager lektionen “Erlang-processer og messaging”?
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
- Introduktion til Erlang og VM
- Erlang-processer og messaging
- Grundlæggende mønstre for samtidighed
- Mønstermatchning og guards