Erlang Language
Processus

Création de processus

Nous créons un nouveau processus simultané en appelant la fonction spawn . La fonction spawn obtiendra en paramètre une fonction Fun que le processus évaluera. La valeur de retour de la fonction spawn est l'identificateur de processus créé (pid).

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

Vous pouvez également utiliser spawn/3 pour démarrer un processus qui exécutera une fonction spécifique à partir d'un module: spawn(Module, Function, Args) .
Vous pouvez également utiliser spawn/2 ou spawn/4 pour démarrer un processus dans un autre nœud: spawn(Node, Fun) ou spawn(Node, Module, Function, Args) .

Message passant

Deux processus erlang peuvent communiquer entre eux, également connus sous le nom de passage de messages .
Cette procédure est asynchrone sous la forme que le processus d'envoi ne s'arrêtera pas après l'envoi du message.

Envoi de messages

Cela peut être réalisé avec la construction Pid ! Message , où Pid est un identificateur de processus valide (pid) et Message est une valeur de tout type de données.

Chaque processus a une "boîte aux lettres" qui contient les messages reçus dans l'ordre reçu. Cette "boîte aux lettres" peut être vidée avec la fonction build flush/0 .

Si un message est envoyé à un processus non existant, le message sera supprimé sans aucune erreur!

Un exemple peut ressembler à ceci, où self/0 renvoie le pid du processus en cours et pid/3 crée un pid.

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

Il est également possible d'envoyer un message à plusieurs processus à la fois, avec Pid3!Pid2!Pid1!Msg .

Recevoir des messages

Les messages reçus peuvent être traités avec la construction de receive .

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

Le Pattern sera comparé aux messages de la "boîte aux lettres" en commençant par le premier et le plus ancien message.
Si un modèle correspond, le message correspondant est supprimé de la "boîte aux lettres" et le corps de la clause est évalué.

Il est également possible de définir des délais avec la construction after .
Un Timeout est soit le temps d'attente en millisecondes ou l'atome infinity .

La valeur de retour de receive est le dernier corps de clause évalué.

Exemple (compteur)

Un compteur (très) simple avec passage de message pourrait ressembler à ce qui suit.

-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.

Interaction avec le compteur.

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

Enregistrer les processus

Il est possible d'enregistrer un processus (pid) dans un alias global.
Cela peut être réalisé avec la fonction build in register(Alias, Pid) , où Alias est l'atome pour accéder au processus en tant que et Pid est l'ID du processus.

L'alias sera disponible globalement!
Il est très facile de créer un état partagé, ce qui n'est généralement pas préférable. ( Voir aussi ici )

Il est possible de désenregistrer un processus avec unregister(Pid) et de recevoir le pid d'un alias avec whereis(Alias) .

Utilisez registered() pour une liste de tous les alias enregistrés.

L'exemple enregistre le totem Atom dans le pid du processus en cours et envoie un message à l'aide de l'atome enregistré.

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