aprendiendo ( Erlang ).

viernes, 15 de julio de 2011

Procesos II. Procesos registrados.

| 0 comentarios |

Cuando enviamos un mensaje a un proceso necesitamos conocer su PID. Esto puede llegar a ser un problema en algunos sistemas. Supongamos por un momento que, tenemos una estructura cliente-servidor entonces, todos los clientes necesitarían saber el PID del servidor para poder interactuar con él.
Erlang provee de un mecanismo para poder distribuir los PID's de sistemas destacados como puede ser un servidor. El registro de procesos es un mecanismo por el cual, asociamos un átomo conocido por todos a un proceso concreto o a su PID para ser más exacto.
Veamos la API que necesitamos para trabajar con procesos registrados o para registrarlos:
  • register(atomo, PID): registra el PID de un proceso a un átomo.
  • unregister(atomo): borra del registro asociado al átomo. Si un proceso termina o muere es automáticamente borrado del registro.
  • whereis(atomo) -> PID | undefined : devuelve el PID asociado al átomo. Si el proceso no esta registrado entonces devuelve undefined.
  • registered(): retorna una lista de procesos registrados en el sistema (átomos).
Retomemos el ejemplo de calculadora del post de Introducción a procesos y realicemos el registro del proceso.
-module(calculadora).
-export([start/0]).

start () ->
    register(calc, spawn(fun calcular/0) ).

calcular() ->
    receive
        {suma, X, Y} ->
            io:format ("~p + ~p = ~p ~n", [X, Y, X+Y]),
            calcular();
        {resta, X, Y} ->
            io:format ("~p - ~p = ~p ~n", [X, Y, X-Y]),
            calcular();
        {multiplica, X, Y} ->
            io:format ("~p * ~p = ~p ~n", [X, Y, X*Y]),
            calcular();
        {divide, X, Y} when Y > 0 ->
            io:format ("~p / ~p = ~p ~n", [X, Y, X/Y]),
            calcular();
        terminar ->
            void;
        Otro ->
            io:format("Error: comando <~p> incorrecto~n", [Otro]), 
            calcular()
    end.
Como puedes ver, en la función start/0, hemos registrado el proceso asociándolo al átomo calc. Esta forma de registrar es muy habitual, pero podría haber utilizado otras como; realizar el spawn/1 haber recogido el PID en una variable y pasárselo al registrador; o haber realizado el spawn/1 y luego registrar utilizando la función self/0.
Compilemos y veamos como se comporta la modificación efectuada:
1> c(calculadora).
{ok,calculadora}
2> registered().
[init,rex,error_logger,kernel_sup,inet_db,
 global_name_server,code_server,file_server_2,
 erl_prim_loader,user_drv,standard_error,standard_error_sup,
 application_controller,kernel_safe_sup,user,global_group]
3> whereis(calc).
undefined
4> calculadora:start().
true
5> whereis(calc).      
<0.44.0>
6> registered().       
[init,rex,error_logger,kernel_sup,inet_db,
 global_name_server,code_server,file_server_2,
 erl_prim_loader,user_drv,standard_error,standard_error_sup,
 application_controller,kernel_safe_sup,user,global_group,
 calc]
7> calc!{suma, 2,5}.
2 + 5 = 7 
{suma,2,5}
8> calc!terminar.   
terminar
9> registered().    
[init,rex,error_logger,kernel_sup,inet_db,
 global_name_server,code_server,file_server_2,
 erl_prim_loader,user_drv,standard_error,standard_error_sup,
 application_controller,kernel_safe_sup,user,global_group]
Se puede apreciar como en principio no esta registrado el proceso, y cuando realizamos la llamada a calculadora:start/0 queda registrado al átomo calc. Podemos untilizar el átomo para el envío de mensajes y una vez terminada la ejecución del proceso queda automáticamente desregistrado.

Publicar un comentario

0 comentarios:

 
Licencia Creative Commons
Aprendiendo Erlang por Verdi se encuentra bajo una Licencia Creative Commons Atribución-NoComercial-CompartirIgual 3.0 Unported.