Grundläggande mönster för samtidighet
Implementera enkla samtidiga applikationer genom att skapa processer och ta emot meddelanden, och utforska grundläggande mönster som klient–server-interaktioner.
Grundläggande mönster för samtidighet är en gratis lektion i Erlang OTP: Programmering av distribuerade och feltoleranta system på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig 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.
Samtidighetsmönster i Erlang
Samtidighetsmönster är beprövade sätt att strukturera hur processer interagerar, så att du kan bygga robusta och förutsägbara samtidiga applikationer.
Mönstret begäran-svar
Mönstret Request-Response är en dialog: en klient skickar en begäran, servern utför arbetet och svarar sedan. Det är ryggraden i interaktiva tjänster.
Bygga en enkel server
En serverprocess loopar över receive, hanterar varje meddelande och svarar med SenderPid ! Reply; self() ger den dess eget PID.
Kod: exempel på ekoserver
Den här ekoservern tar emot valfritt meddelande, hämtar avsändarens PID och skickar meddelandet direkt tillbaka med en markering som visar att det är ett eko.
-module(echo_server).
-export([start/0, loop/0]).
start() ->
spawn(echo_server, loop, []).
loop() ->
receive
{FromPid, Message} ->
FromPid ! {self(), echoed, Message},
loop();
_ ->
io:format("Server received unknown message.~n"),
loop()
end.Kod: interaktion med ekoklienten
Den matchande ekoklienten startar servern, skickar {self(), msg} så att servern vet vart den ska svara och väntar sedan på svaret.
-module(echo_client).
-export([run/0]).
run() ->
ServerPid = echo_server:start(),
io:format("Server started with PID: ~p~n", [ServerPid]),
Request = "Hello Erlang!",
ServerPid ! {self(), Request},
io:format("Client sent: ~p to server ~p~n", [Request, ServerPid]),
receive
{_ServerPid, echoed, Response} ->
io:format("Client received reply: ~p~n", [Response]);
_ ->
io:format("Client received unexpected message.~n")
after 5000 ->
io:format("Client timed out waiting for reply.~n")
end.Köra ekosystemet
För att köra det kompilerar du båda modulerna och anropar echo_client:run() i skalet – en komplett request-response-cykel mellan två processer.
Det asynkrona mönstret
Det asynkrona mönstret (”skicka och glöm”): klienten skickar ett meddelande och fortsätter direkt medan mottagaren arbetar i bakgrunden. Det passar utmärkt för loggning eller jobb.
Kod: asynkron loggningsprocess
Den här loggningsprocessen tar bara emot meddelanden och skriver ut dem utan att skicka något svar – serversidan av det asynkrona mönstret.
-module(async_logger).
-export([start/0, loop/0]).
start() ->
spawn(async_logger, loop, []).
loop() ->
receive
{log, Message} ->
io:format("LOG: ~p~n", [Message]),
loop();
_ ->
io:format("Logger received unknown message.~n"),
loop()
end.Kod: asynkron loggningsklient
Den matchande klienten startar loggningen, skickar ett meddelande och fortsätter direkt utan att vänta – icke-blockerande enligt design.
-module(logger_client).
-export([run/0]).
run() ->
LoggerPid = async_logger:start(),
io:format("Logger started with PID: ~p~n", [LoggerPid]),
LoggerPid ! {log, "User X logged in."},
io:format("Client sent first log. Continuing...~n"),
timer:sleep(10), % Give logger a moment to process
LoggerPid ! {log, "User Y viewed profile."},
io:format("Client sent second log. Task complete.~n").Test av samtidighetsmönster
Du bygger ett system där en användare laddar upp en stor video. Din huvudprocess måste omedelbart meddela användaren ”Videon har laddats upp och bearbetas i bakgrunden”, medan en separat process omkodar videon. Vilket mönster beskriver bäst interaktionen mellan huvudprocessen och videoomkodaren?
Sammanfattning: grundläggande samtidighetsmönster
Sammanfattning: Request-Response väntar på ett svar (interaktivt arbete), medan Asynchronous skickar och glömmer (bakgrundsjobb). Det är dina viktigaste verktyg för samtidighet.
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 ”Grundläggande mönster för samtidighet” gratis?
Ja – hela texten till ”Grundläggande mönster för samtidighet” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Erlang OTP: Programmering av distribuerade och feltoleranta system, kan Ni uppgradera till CoddyKit PRO. Kursen i Erlang OTP: Programmering av distribuerade och feltoleranta system innehåller totalt 4 lektioner.
Vad lär jag mig i ”Grundläggande mönster för samtidighet”?
Implementera enkla samtidiga applikationer genom att skapa processer och ta emot meddelanden, och utforska grundläggande mönster som klient–server-interaktioner. 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 3 av 4.
Hur lång tid tar lektionen ”Grundläggande mönster för samtidighet”?
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
- Introduktion till Erlang och VM
- Erlang-processer och meddelanden
- Grundläggande mönster för samtidighet
- Mönstermatchning och guards