Processos e troca de mensagens em Erlang

Erlang's Core: The Process

Why Erlang Processes?

Spawning a New Process

-module(process_spawn).
-export([start/0, hello_world_process/0]).

hello_world_process() ->
    io:format("Hello from a new Erlang process!~n").

start() ->
    % Spawns a new process running hello_world_process/0
    Pid = spawn(process_spawn, hello_world_process, []),
    io:format("Spawned process with PID: ~p~n", [Pid]).

Understanding Process IDs (PIDs)

Sending Messages with '!'

-module(message_sender).
-export([start/0, receiver_process/0, sender_process/1]).

receiver_process() ->
    io:format("Receiver process ~p started.~n", [self()]),
    % This process will just print its PID for now.
    % It doesn't receive messages in this version.
    timer:sleep(1000). % Keep process alive for a moment

sender_process(ReceiverPid) ->
    io:format("Sender process ~p sending message to ~p...~n", [self(), ReceiverPid]),
    ReceiverPid ! {hello, "from sender"},
    io:format("Message sent!~n").

start() ->
    ReceiverPid = spawn(message_sender, receiver_process, []),
    io:format("Receiver spawned with PID: ~p~n", [ReceiverPid]),
    sender_process(ReceiverPid).

Receiving Messages: 'receive'

-module(message_receiver).
-export([start/0, my_receiver/0, my_sender/1]).

my_receiver() ->
    io:format("Receiver ~p waiting for messages...~n", [self()]),
    receive
        {hello, Msg} ->
            io:format("Receiver ~p received: ~p~n", [self(), Msg]);
        _AnyOtherMessage ->
            io:format("Receiver ~p received an unexpected message: ~p~n", [self(), _AnyOtherMessage])
    end,
    io:format("Receiver ~p finished.~n", [self()]).

my_sender(ReceiverPid) ->
    io:format("Sender ~p sending message to ~p.~n", [self(), ReceiverPid]),
    ReceiverPid ! {hello, "World"},
    io:format("Sender ~p sent message.~n", [self()]).

start() ->
    ReceiverPid = spawn(message_receiver, my_receiver, []),
    timer:sleep(100), % Give receiver time to start
    my_sender(ReceiverPid).

A Full Messaging Example

-module(full_message_example).
-export([start/0, server_loop/0, client_action/1]).

server_loop() ->
    io:format("Server ~p started, waiting for requests...~n", [self()]),
    receive
        {request, ClientPid, Message} ->
            io:format("Server ~p received request from ~p: ~p~n", [self(), ClientPid, Message]),
            ClientPid ! {response, self(), "Got your message!"};
        _Other ->
            io:format("Server ~p received unexpected: ~p~n", [self(), _Other])
    end.

client_action(ServerPid) ->
    io:format("Client ~p sending request to server ~p...~n", [self(), ServerPid]),
    ServerPid ! {request, self(), "Can you hear me?"},
    receive
        {response, ServerPid, Reply} ->
            io:format("Client ~p received reply from ~p: ~p~n", [self(), ServerPid, Reply])
    end.

start() ->
    ServerPid = spawn(full_message_example, server_loop, []),
    timer:sleep(100), % Give server time to start
    client_action(ServerPid).

Asynchronous Communication

The Process Mailbox

Knowing Your Own PID: `self()`

-module(self_example).
-export([start/0, print_self/0]).

print_self() ->
    io:format("Hello, my PID is: ~p~n", [self()]).

start() ->
    io:format("Parent process PID: ~p~n", [self()]),
    spawn(self_example, print_self, []).

Quick Check: Message Flow

Recap: Processes & Messaging