CS 3060: Programming Languages

Erlang

Robert C. Green II, Ph.D.

Day 3

The Basic Loop

                        -module(translate).
-export([loop/0]).

loop() ->
    receive
        "casa" ->
            io:format("house~n"),
            loop();
        "blanca" ->
            io:format("white~n"),
            loop();
        _ ->
            io:format("I don't understand.~n"),
            loop()
        end.            
                    

Spawning a Process

                        
Pid = spawn(fun translate:loop/0).
                        
                    

Sending Messages

                        
Pid ! "casa".

Pid ! "blanca".

Pid ! "loco".
                        
                    

Receiving Messages

translate_service.erl
                        
Translator = spawn(fun translate_service:loop/0)

translate_service:translate(Translator, "blanca").

translate_service:translate(Translator, "casa")
                        
                    

3 Idioms for Concurrency

I don't care

                            
                spawn(Fun) -> pid()
                spawn(Node, Fun) -> pid()
                spawn(Module, Function, Args) -> pid()
                spawn(Node, Module, Function, Args) -> pid()
                            
                        

Let it crash

                            
                spawn_link(Fun) -> pid()
                spawn_link(Node, Fun) -> pid()
                spawn_link(Module, Function, Args) -> pid()
                spawn_link(Node, Module, Function, Args) -> pid()
                            
                        

Let me know

                            
                process_flag(trap_exit, true),
                spawn_link(...)
                            
                        
                            
                process_flag(trap_exit, true),
                link(...)
                            
                        

Linked Processes

When a linked process dies, it sends a termination signal to its linkees
                        
-module(roulette).
-export([loop/0]).

loop() ->
    receive
        3 -> io:format("bang.~n"), 
             exit({roulette,die,at,erlang:time()});

        _ -> io:format("click~n"), loop()
    end.
                        
                    

Linked Processes

                        
c(roulette).

Gun = spawn(fun roulette:loop/0).
                        
                    
                        

erlang:is_process_alive(Gun).

                        
                    

Linked Processes - Monitor

Let's you know if a process dies
                        -module(coroner).
-export([loop/0]).

loop() ->
    process_flag(trap_exit, true),
    receive
        {monitor, Process} ->
            link(Process),
            io:format("Monitoring process.~n"),
            loop();
        {'EXIT', From, Reason} ->
            io:format("The shooter ~p died with reason ~p.", 
                        [From, Reason]),
            io:format("Start another one.~n"),
            loop()
        end.

                        
                    

Linked Processes - Monitor

Let's you know if a process dies
                        -module(coroner).
Revolver=spawn(fun roulette:loop/0).

Coroner=spawn(fun coroner:loop/0).

Coroner ! {monitor, Revolver}.

                        
                    

Linked Processes - Monitor

Can also re-spawn a process
                        -module(doctor).
-export([loop/0]).
    
loop() ->
    process_flag(trap_exit, true),
    receive
        new ->
            io:format("Creating and monitoring process.~n"),
            register(revolver, spawn_link(fun roulette:loop/0)),
            loop();
        {'EXIT', From, Reason} ->
            io:format("The shooter ~p died with reason ~p.", 
                        [From, Reason]),
                io:format(" Restarting. ~n"),
            self() ! new,
            loop()
    end.

                        
                    

Assignment

Keep working on the Assignment

Resources