{"id":610,"date":"2011-05-26T08:24:35","date_gmt":"2011-05-26T07:24:35","guid":{"rendered":"http:\/\/trigonakis.com\/blog\/?p=610"},"modified":"2011-05-26T08:24:35","modified_gmt":"2011-05-26T07:24:35","slug":"introduction-to-erlang-message-passing","status":"publish","type":"post","link":"http:\/\/trigonakis.com\/blog\/2011\/05\/26\/introduction-to-erlang-message-passing\/","title":{"rendered":"Introduction to Erlang : Message Passing"},"content":{"rendered":"
This entry is part 15 of 16 in the series Introduction to Erlang<\/a><\/div>

Message Passing<\/h3>\n

The communication model (among processes) in Erlang is message passing<\/i>. No much need to be said about this. Erlang processes share no memory<\/strong>. The way that processes communicate is via (asynchronous) message passing. Every process (even the shell) holds a mailbox queue where incoming messages are placed until received by the process. Message passing is asynchronous because the sending process does not block on send. On the other hand, receiving a message in Erlang is a blocking operation.<\/p>\n

Characteristics<\/h4>\n

In this subsection I will describe some of the characteristics of message passing in Erlang.<\/p>\n

Asynchronous<\/h5>\n

As I already mentioned, message passing in Erlang is a non-blocking operation.<\/p>\n

Data Copy<\/h5>\n

The message’s data are copied from the sending process to the receiver’s message queue, so the receiver gets a fresh copy of the data.<\/p>\n

Ordering<\/h5>\n

Erlang runtime guarantees that if two messages are sent from node A<\/code> to node B<\/code> and both are delivered, then the ordering of these messages is kept (causal ordering).<\/p>\n

Successful Send<\/h5>\n

The send operation always succeeds (even if the target is a non-existing process) and evaluates to the data sent. An exception is when trying to send data to a non-existing registered process.
\n<\/p>\n

Sending Messages<\/h3>\n

Erlang uses the exclamation mark (!<\/strong>) as the operator for sending a message. ! is equivalent with the erlang:send\/2<\/code> function but is more commonly used because of its compactness. The ! operator is used as following<\/p>\n

\r\n%send message Message to the process with pid Pid\r\nPid ! Message\r\n<\/pre>\n
and returns the message sent. Returning the message sent allows to send multiple messages “at once”; all <\/p>\n
\r\nPid1 ! Message, Pid2 ! Message, Pid3 ! Message\r\nPid1 ! (Pid2 ! (Pid3 ! Message))\r\nPid1 ! Pid2 ! Pid3 ! Message\r\n<\/pre>\n
are equivalent.<\/p>\n
Example<\/h4>\n
As I have mentioned before, the shell is nothing more than a process. As a process, it has a message queue. In order to print and empty the shell’s message queue we can use the flush\/0<\/code> BIF.<\/p>\n
\r\n1> self() ! any_erlang_term_can_be_sent.\r\nany_erlang_term_can_be_sent %notice that the msg sent\r\n                            %was also returned\r\n2> flush().                             \r\nShell got any_erlang_term_can_be_sent\r\nok\r\n3> self() ! [this, is, a, list, 'of', atoms].\r\n[this,is,a,list,'of',atoms]\r\n4> self() ! {this, [is, a], tuple, {'!', '!'}}.\r\n{this,[is,a],tuple,{'!','!'}}\r\n5> self() ! {self(), 123}.\r\n{<0.35.0>,123}\r\n6> flush().\r\nShell got [this,is,a,list,'of',atoms]\r\nShell got {this,[is,a],tuple,{'!','!'}}\r\nShell got {<0.35.0>,123}\r\nok\r\n7> Pid1 = self(), Pid2 = self(), Pid3 = self().\r\n<0.35.0>\r\n8> Pid1 ! msg, Pid2 ! msg, Pid3 ! msg.\r\nmsg\r\n9> flush().\r\nShell got msg\r\nShell got msg\r\nShell got msg\r\nok\r\n10> Pid1 ! (Pid2 ! (Pid3 ! msg)).      \r\nmsg\r\n11> flush().                     \r\nShell got msg\r\nShell got msg\r\nShell got msg\r\nok\r\n12> Pid1 ! Pid2 ! Pid3 ! msg.    \r\nmsg\r\n13> flush().                 \r\nShell got msg\r\nShell got msg\r\nShell got msg\r\nok\r\n<\/pre>\n
Receiving Messages<\/h3>\n
Erlang uses pattern matching for receiving messages (same as in function clause selection and the case<\/code> statement). The receive<\/code> statement is used to deliver messages from the message queue. Its format is the following:<\/p>\n
\r\nreceive\r\n    Pattern1 when Guard1 ->\r\n\tDo1;\r\n    Pattern2 when Guard2 ->\r\n\tDo2;\r\n    _Other ->\r\n\tCatch_all\r\nend\r\n<\/pre>\n
Notice the similarities of the clauses with the ones in a case<\/code> statement. The last clause is the “catch all” clause since it will match with any message (that did not match with a previous clause). Of course having a catch all clause is optional.<\/p>\n
Receiving Order<\/h4>\n
The message processing is done in a FIFS<\/i> (First In – First Served) order. Every incoming message is placed in the tail of the process’ message queue. When a receive<\/code> statement is met the following processing happens:<\/p>\n
    \n
  1. The first message (head of the message queue) is pattern matched against the first receive clause. If match, execute the clause’s body, else go to the next step.<\/li>\n
  2. The same message is pattern matched against the second (if any) receive clause. If match, execute the clause’s body, else go to the next step.<\/li>\n
  3. …<\/li>\n
  4. The same message is pattern matched against the last clause. If match, execute the clause’s body, else go to the next step.<\/li>\n
  5. The same iterative process starts again from step 1, but now with the next message from the message queue.<\/li>\n<\/ol>\n
    Of course, the message (if any) that is delivered through receive<\/code> is removed from the message queue.<\/p>\n
    Examples<\/h3>\n
    Ping Pong<\/h4>\n
    A simple example where 2 processes exchange “ping-pong” messages.<\/p>\n
    \r\n-module(pingpong).\r\n-export([play\/1]).\r\n\r\nplay(N) when is_integer(N), N > 0 ->\r\n    Pong = spawn(fun pong\/0),\r\n    ping(N, Pong).\r\n\r\nping(0,Pong) ->\r\n    Pong ! exit,\r\n    ok;\r\nping(N, Pong) ->\r\n    Pong ! {self(), ping},\r\n    receive\r\n\tpong ->\r\n\t    io:format(\"~w : pong [~w]~n\", [self(), N])\r\n    end,\r\n    ping(N - 1, Pong).\r\n\r\npong() ->\r\n    receive\r\n\t{From, ping} ->\r\n\t    io:format(\"~w : ping~n\", [self()]),\r\n\t    From ! pong,\r\n\t    pong();\r\n\texit ->\r\n\t    ok\r\n    end.\t    \r\n<\/pre>\n
    “Details”<\/h5>\n
    Some details about the above ping pong implementation are:<\/p>\n