Erlang OTP: Programmering af distribuerede og fejltolerante systemer · Lektion

Global procesregistrering

Håndtér globale procesnavne, og find processer på tværs af en distribueret Erlang-klynge til koordinerede operationer.

Lektion 3 af 411 trin

Global procesregistrering er en gratis Erlang OTP: Programmering af distribuerede og fejltolerante systemer-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser 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.

Globale navne på tværs af noder

I distribueret Erlang har processer ofte brug for at finde hinanden, selv når de kører på forskellige maskiner. Hvordan finder du en proces, når du ikke ved, hvilken node den kører på?

Erlangs global-modul tilbyder en løsning: global procesregistrering. Det gør det muligt at give en proces et entydigt navn, som er kendt på alle forbundne noder i din klynge.

Lokale og globale processer

Normalt er navnet kun kendt på den lokale node, når du registrerer en proces med register/2. Hvis my_process findes på nodeA@host, kan en proces på nodeB@host ikke finde den kun ud fra navnet.

Global registrering løser dette! Den fungerer som en distribueret katalogtjeneste. Enhver proces på enhver forbundet node kan slå et globalt registreret navn op og få det tilhørende proces-id (PID), uanset hvor processen kører.

`global:register_name/2`

Hvis du vil gøre en proces globalt tilgængelig, bruger du global:register_name(Name, Pid).

Name: En atom, der bliver det entydige globale navn (f.eks. my_service).
Pid: Proces-id'et for den proces, du vil registrere.

Hvis navnet allerede er optaget, returnerer register_name {false, OldPid}; ellers returnerer den true. global-modulet sikrer, at et globalt navn er entydigt i hele den distribuerede klynge.

`global:whereis_name/1`

Når en proces er registreret, kan enhver anden proces finde den ved hjælp af global:whereis_name(Name).

Name: Det globale navn (en atom), du leder efter.

Denne funktion returnerer PID'et for den registrerede proces, hvis den findes, eller atomen undefined, hvis ingen proces er registreret under navnet.

Det er afgørende at kontrollere, om resultatet er undefined, før du forsøger at sende meddelelser til det returnerede PID.

Komplet demonstration af global kommunikation

Dette kørbare eksempel samler det hele! En serverproces starter og registrerer sig globalt. Efter en kort forsinkelse finder en klientproces derefter denne globale server og sender den en meddelelse, som udløser et svar.

Bemærk, hvordan global:register_name sikrer, at serveren er kendt, og hvordan global:whereis_name gør det muligt for klienten at finde den, så de kan kommunikere problemfrit.

-module(global_demo).
-export([main/0]).

% Server Functions
server_init() ->
    case global:register_name(my_global_service, self()) of
        true ->
            io:format("Server (~p) registered as my_global_service~n", [self()]),
            server_loop();
        {false, OldPid} ->
            io:format("Error: my_global_service already registered by ~p~n", [OldPid])
    end.

server_loop() ->
    receive
        {From, hello} ->
            io:format("Server (~p) received 'hello' from ~p~n", [self(), From]),
            From ! {self(), "Hi from server!"},
            server_loop();
        _ ->
            io:format("Server (~p) received unknown message~n", [self()]),
            server_loop()
    end.

% Client Functions
client_task() ->
    io:format("Client (~p) trying to find my_global_service...~n", [self()]),
    case global:whereis_name(my_global_service) of
        undefined ->
            io:format("Client: my_global_service not found!~n");
        ServerPid ->
            io:format("Client: Found server ~p, sending 'hello'...~n", [ServerPid]),
            ServerPid ! {self(), hello},
            receive
                {ServerPid, Response} ->
                    io:format("Client: Received response from server: '~s'~n", [Response])
            after 5000 ->
                io:format("Client: No response from server within 5 seconds.~n")
            end
    end.

% Main entry point
main() ->
    % Start the server process
    spawn(?MODULE, server_init, []),
    timer:sleep(100), % Give server time to register

    % Start the client process
    spawn(?MODULE, client_task, []),

    timer:sleep(2000). % Allow processes to run and communicate

Fjernelse af globale navne

Når en globalt registreret proces afsluttes, afregistrerer modulet global automatisk dens navn. Du kan dog også eksplicit afregistrere et navn ved hjælp af global:unregister_name(Name).

Det er nyttigt, hvis du vil erstatte en tjeneste, eller hvis en proces midlertidigt skal frigive sit globale navn. Husk, at andre processer ikke længere kan finde navnet, når det først er afregistreret.

Håndtering af navnekollisioner

Hvad sker der, hvis to forskellige processer (selv på forskellige noder) forsøger at registrere det samme globale navn?

Modulet global sikrer, at et globalt navn er entydigt i hele det distribuerede system. Den første proces, der registrerer navnet korrekt, vinder. Efterfølgende forsøg på at registrere det samme navn mislykkes og returnerer {false, OldPid}, hvilket angiver, hvem der allerede har navnet.

Det forhindrer tvetydighed og sikrer, at whereis_name/1 altid returnerer én korrekt PID.

Praktiske anvendelser

Global procesregistrering er ideel til at implementere:

Singleton-tjenester: En enkelt instans af en tjeneste (f.eks. en konfigurationsadministrator eller en logfører), som er tilgængelig overalt.
Ressourceadministratorer: En proces, der er ansvarlig for at administrere en delt ressource, som flere dele af dit distribuerede system skal have adgang til.
Indgangspunkter: Et velkendt navn til hovedindgangspunktet i en distribueret applikation.

Det forenkler procesopdagelse i komplekse distribuerede arkitekturer.

Sådan fungerer global registrering

Modulet global udfører sin magi ved at vedligeholde en ensartet visning af registrerede navne på tværs af alle forbundne Erlang-noder.

Når et navn registreres, udsendes disse oplysninger til alle andre noder. Når en node opretter eller afbryder forbindelsen, opdaterer modulet global sin interne tilstand, så den afspejler den aktuelle klyngetopologi og de tilgængelige globale navne.

Det sikrer, at global:whereis_name/1 hurtigt kan finde den korrekte PID, uanset hvor den befinder sig.

Kontrol af global registrering

Forestil dig et distribueret Erlang-system med to noder, nodeA og nodeB, der begge er forbundne. En proces på nodeA registrerer sig korrekt med global:register_name(my_service, self()).

Hvad sker der, hvis en proces på nodeB derefter forsøger at kalde global:register_name(my_service, self())?

Besvar den i den interaktive lektion

Globale navne: En distribueret katalogtjeneste

I denne lektion lærte du om global procesregistrering ved hjælp af Erlangs modul global:

Det giver mulighed for at tildele entydige navne til processer, som kan findes i hele en distribueret Erlang-klynge.
global:register_name(Name, Pid) gør en proces globalt tilgængelig.
global:whereis_name(Name) gør det muligt for enhver proces på enhver forbundet node at finde den PID, der er knyttet til et globalt navn.
Modulet global håndterer navnes entydighed og afregistrerer automatisk processer, når de afsluttes, så administrationen af distribuerede processer bliver enklere.

Globale navne er grundlæggende, når du bygger robuste, fejltolerante og søgbare tjenester i distribuerede Erlang-applikationer.

Gratis at komme i gang

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

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Global procesregistrering” gratis?

Ja — alle 3 lektioner i læringssporet Erlang OTP: Programmering af distribuerede og fejltolerante systemer, inklusive “Global procesregistrering”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Erlang OTP: Programmering af distribuerede og fejltolerante systemer-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Global procesregistrering”?

Håndtér globale procesnavne, og find processer på tværs af en distribueret Erlang-klynge til koordinerede operationer. 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 3 af 4.

Hvor lang tid tager lektionen “Global procesregistrering”?

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

← Tilbage til Erlang OTP: Programmering af distribuerede og fejltolerante systemer