Erlang Language
Processen

Processen maken

We creëren een nieuw gelijktijdig proces door de spawn functie aan te roepen. De spawn functie krijgt als parameter een functie Fun die het proces zal evalueren. De retourwaarde van de spawn functie is de gecreëerde proces-ID (pid).

1> Fun = fun() -> 2+2 end.
#Fun<erl_eval.20.52032458>
2> Pid = spawn(Fun).
<0.60.0>

Je kunt ook spawn/3 gebruiken om een proces te starten dat een specifieke functie van een module uitvoert: spawn(Module, Function, Args) .
Of gebruik spawn/2 of spawn/4 dezelfde manier om een proces in een ander knooppunt te starten: spawn(Node, Fun) of spawn(Node, Module, Function, Args) .

Bericht overslaan

Twee erlang-processen kunnen met elkaar communiceren, ook bekend als het doorgeven van berichten .
Deze procedure is asynchroon in de vorm dat het verzendproces niet stopt na het verzenden van het bericht.

Berichten versturen

Dit kan worden bereikt met de constructie Pid ! Message , waarbij Pid een geldige proces-ID (pid) is en Message een waarde van elk gegevenstype is.

Elk proces heeft een "mailbox" die de ontvangen berichten in de ontvangen volgorde bevat. Deze "mailbox" kan worden geleegd met de flush/0 functie.

Als een bericht naar een niet-bestaand proces wordt verzonden, wordt het bericht zonder fouten verwijderd!

Een voorbeeld kan er als volgt uitzien, waarbij self/0 de pid van het huidige proces retourneert en pid/3 een pid maakt.

1> Pidsh = self().
<0.32.0>
2> Pidsh ! hello.
hello
3> flush().
Shell got hello
ok
4> <0.32.0> ! hello.
* 1: syntax error before: ’<’
5> Pidsh2 = pid(0,32,0).
<0.32.0>
6> Pidsh2 ! hello2.
hello2
7> flush().
Shell got hello2
ok

Het is ook mogelijk om een bericht naar meerdere processen tegelijk te verzenden, met Pid3!Pid2!Pid1!Msg .

Berichten ontvangen

Ontvangen berichten kunnen worden verwerkt met de receive constructie.

receive
  Pattern1            -> exp11, .., exp1n1;
  Pattern2 when Guard -> exp21, .., exp2n2;
  ...
  Other               -> exp31, .., exp3n3;
  ...
  after Timeout       -> exp41, .., exp4n4
end

Het Pattern wordt vergeleken met de berichten in de "mailbox", beginnend met het eerste en oudste bericht.
Als een patroon overeenkomt, wordt het overeenkomende bericht verwijderd uit de "mailbox" en wordt de hoofdtekst geëvalueerd.

Het is ook mogelijk om time-outs te definiëren met de after constructie.
Een time- Timeout is de wachttijd in milliseconden of de infinity atoom.

De retourwaarde van receive is de laatst geëvalueerde clausule.

Voorbeeld (teller)

Een (zeer) eenvoudige teller met het doorgeven van berichten kan er in het volgende uitzien.

-module(counter0).
-export([start/0,loop/1]).

% Creating the counter process.
start() ->
    spawn(counter0, loop, [0]).

% The counter loop.
loop(Val) ->
    receive
        increment ->
           loop(Val + 1)
    end.

Interactie met de balie.

1> C0 = counter0:start().
<0.39.0>
2> C0!increment.
increment
3> C0!increment.
increment

Registreer processen

Het is mogelijk om een proces (pid) te registreren bij een globale alias.
Dit kan worden bereikt met de ingebouwde register(Alias, Pid) , waarbij Alias het atoom is om toegang tot het proces te krijgen en Pid de proces-id is.

De alias zal wereldwijd beschikbaar zijn!
Het is heel eenvoudig om een gedeelde status te maken, wat meestal niet de voorkeur heeft. ( Zie ook hier )

Het is mogelijk om een proces af te whereis(Alias) met unregister(Pid) en de pid te ontvangen van een alias met whereis(Alias) .

Gebruik registered() voor een lijst met alle geregistreerde aliassen.

Het voorbeeld registreert de Atom foo in de pid van het huidige proces en verzendt een bericht met behulp van het geregistreerde Atom.

1> register(foo, self()).
true
2> foo ! 'hello world'.
'hello world'