DEV Community: ThiagosLima

Process communication in Elixir

ThiagosLima — Thu, 21 Oct 2021 18:26:46 +0000

The focus of this post is to explain the communication between processes in elixir in a simple way. Here you can read the portuguese version of this article. When you've finished reading, you'll have a basic understanding of how to create processes and how they send and receive messages.

How to create processes

A process is something that can do things in isolation and concurrently. Well... this is pretty vague. Let's try a more concrete example. Let's say you are a mouse process. You can do many things that mice do, like hiding or eating cheese for example. You are independent, you don't need other people to do what you want and they don't interfere with your activities. That is, you do it in isolation. In a mice contest to see who eats the most cheese, everyone could do it concurrently and in parallel. Everyone eats at the same time and not one at a time.

Now that we have an idea of what a process is, let's imagine that you want to make a new friend, that is, another process. So let's create the cat process. We can do this with the spawn function.

The spawn function creates a new process and performs a function on it. It has two arities: spawn/1 takes a function and spawn/3 takes a module, a function as an atom and a list of parameters. Here we are going to use the second form because we are going to define Cat in a module. The create function just prints a message. You can put the code below in a file called mouse.exs and run it with elixir mouse.exs. If you do this you will see the commented result.

# mouse.exs
defmodule Cat do
  def create do
    IO.puts("You create cat")
  end
end

# Here you create a cat
spawn(Cat, :create, [])

# Result:
# "You create cat"

Communication between processes

After creating a new process, your friend the cat, you want to talk to him. But remember that processes are isolated. Imagine that everyone lives in their own home with social distance. So how to communicate with him? Millions of years ago people used a form of communication called mail. Processes communicate in a similar way. So to talk to your friend you will send a message like that.

Sending and receiving messages

We send a message with the send/2 function. We pass to this function two things: the receiver and the message. But how will our code know how to send the message to the cat process? Thankfully, the spawn function returns an identifier of the process created for us, as if it were its address. So let's save the spawn return in the variable cat.

cat = spawn(Cat, :create, [])

The cat needs to know how to receive this message. For this we defined the receive block. Here's how it works: the cat will look inside the mailbox and decide what is important. That is, for which messages he wants to do something.

# mouse.exs
defmodule Cat do
  def create do
    receive do
      :how_is_it_going -> IO.puts("Good!")
    end
  end
end

# Here you create a cat
cat = spawn(Cat, :create, [])

# Send the message
send(cat, :how_is_it_going)

# Result:
# "Good!"

Answering back

Our code has a problem. Imagine IO.puts("Good!") as if the cat had said that. But you are in your own homes, remember? So you didn't hear his answer. Because processes communicate with messages, he would have to send you a message back.

Glad you already know how to send a message. Just make the cat respond with send(mouse, :good) and it's all right! However, how will the cat know that the message came from the mouse? To do this, let's say in the message who the sender was. We have to change the cat's receive to care for messages that follow the pattern {:how_is_it_going, sender}. So he can reply to the right person with send(sender, :good). It looks like this:

receive do
  {:how_is_it_going, sender} -> send(sender, :good)
end

Now the mouse needs to identify itself to send the message send(cat, {:how_is_it_going, mouse}). Remember that the mouse is the current process. To identify the current process in the code we use the self/0 function. It's like we're getting our own address. So we save its return in a variable mouse = self().

# This is you
mouse = self()

# Send the message
send(cat, {:how_is_it_going, mouse})

Almost everything is ready. We just need to look in the mouse's mailbox for the message the cat sent and decide what to do. The entire code would look like this:

# mouse.exs
defmodule Cat do
  def create do
    receive do
      {:how_is_it_going, sender} -> send(sender, :good)
    end
  end
end

# This is you
mouse = self()

# Here you create a cat
cat = spawn(Cat, :create, [])

# Send the message
send(cat, {:how_is_it_going, mouse})

# Look in the mouse's mailbox
receive do
  :good -> IO.puts("Nice!")
end

# Result:
# "Nice!"

Temporary Process

You can check whether a process is alive with the Process.alive?/1 function. Let's run the same code above but see when the cat process is alive by adding IO.puts("Is the cat alive? #{Process.alive?(cat)}").

# mouse.exs
defmodule Cat do
  def create do
    receive do
      {:how_is_it_going, sender} -> send(sender, :good)
    end
  end
end

# This is you
mouse = self()

# Here you create a cat
cat = spawn(Cat, :create, [])

IO.puts("Is the cat alive? #{Process.alive?(cat)}")

# Send the message
send(cat, {:how_is_it_going, mouse})

# Look in the mouse's mailbox
receive do
  :good -> IO.puts("Nice!")
end

IO.puts("Is the cat alive? #{Process.alive?(cat)}")

# Result:
# Is the cat alive? true
# Nice!
# Is the cat alive? false

We can see that the process was alive, but after answering it died. Why did this happen?

To understand what happened let's look at the create function. Here we defined a receive block. Since the mouse received the message back, communication is correct. But what happens after the cat responds? Nothing else happens in the cat process. As such, it no longer needs to exist and the process dies!

def create do
  receive do
    {:how_is_it_going, sender} -> send(sender, :good)
  end
end

Permanent Process

To keep the process alive, let's make sure it doesn't respond to just one message. It will keep checking messages and replying. We can do this by defining the check_messages/0 function and passing the receive block to it.

def create do
  check_messages()
end

def check_messages do
  receive do
    {:how_is_it_going, sender} -> send(sender, :good)
  end

  check_messages()
end

So the only thing the create function does is to tell the cat to check the messages. Now look at the last line of check_messages/0. It calls itself! That is, whenever it ends, it goes back to the beginning. It's a recursive function. That way the cat checks messages forever and doesn't die. The whole code looks like this:

# mouse.exs
defmodule Cat do
  def create do
    check_messages()
  end

  def check_messages do
    receive do
      {:how_is_it_going, sender} -> send(sender, :good)
    end

    check_messages()
  end
end

# This is you
mouse = self()

# Here you create a cat
cat = spawn(Cat, :create, [])

IO.puts("Is the cat alive? #{Process.alive?(cat)}")

# Send the message
send(cat, {:how_is_it_going, mouse})

# Look in the mouse's mailbox
receive do
  :good -> IO.puts("Nice!")
end

IO.puts("Is the cat alive? #{Process.alive?(cat)}")

# Result:
# Is the cat alive? true
# Nice!
# Is the cat alive? true

Conclusion

Here you learned the basics of how to create processes with spawn. How they send messages with send/2 and receive messages with the receive block. You saw a little bit about how a process can die and how to keep it alive. And the best of all, cats and mice can be friends after all!

Resources

You can find all the source code in this repo.
This is a portuguese version of the article.
For more information about process, you can access the official guide.
The documentation of the used functions:
- spawn
- send
- receive
- self
- IO.puts
- Process.alive?

Comunicação entre procesos em Elixir

ThiagosLima — Thu, 07 Oct 2021 22:16:18 +0000

O foco dessa postagem é explicar a comunicação entre processos em elixir de forma simples em português. Então toda a postagem e os exemplos de código estão nessa língua. Você pode ler a versão em inglês aqui. Quando terminar de ler você terá um entendimento básico de como criar processos e como eles enviam e recebem mensagens.

Como criar processos

Um processo é algo que pode fazer coisas de forma isolada e concorrente. Bem... isso ficou muito vago. Vamos tentar um exemplo mais concreto. Digamos que você seja um rato. Você pode fazer várias coisas que os ratos fazem, como se esconder ou comer queijo por exemplo. Você é independente, não precisa de outras pessoas para fazer o que quer e eles não interferem nas suas atividades. Ou seja, você faz isso de forma isolada. Em um concurso de ratos para ver qual come mais queijo, todos poderiam fazer isso de forma concorrente e paralela. Todos comem ao mesmo tempo e não um de cada vez.

Agora que temos uma noção do que é um processo, vamos imaginar que você quer fazer um novo amigo, ou seja, outro processo. Então vamos criar o processo gato. É possível fazer isso com a função spawn.

A função spawn cria um novo processo e executa uma função nele. Ela tem duas aridades: spawn/1 recebe uma função e spawn/3 recebe um módulo, uma função como um átomo e uma lista de parâmetros. Aqui vamos utilizar a segunda forma porque vamos definir o Gato em um módulo. A função criar apenas imprime uma mensagem. Você pode colocar o código abaixo em um arquivo chamado gato.exs e executar com elixir gato.exs. Se fizer isso vai ver o resultado comentado.

# gato.exs
defmodule Gato do
  def criar do
    IO.puts("Você criou um gato")
  end
end

# Cria um gato
spawn(Gato, :criar, [])

# Resultado:
# "Você criou um gato"

Comunicação entre processos

Depois de criar um novo processo, seu amigo o gato, você quer falar com ele. Mas lembre-se que os processos são isolados. Imagine que cada um vive em sua própria casa com distanciamento social. Então como se comunicar com ele? Há milhões de anos atrás as pessoas utilizavam um forma de comunicação chamada correio. Os processos se comunicam de forma parecida. Então para falar com seu amigo você vai enviar uma mensagem desse jeito.

Enviando e recebendo mensagens

Enviamos uma mensagem com a função send/2. Passamos para essa função duas coisas: o destinatário da mensagem e qual é a mensagem. Mas como nosso código vai saber enviar a mensagem para o processo gato? Ainda bem que a função spawn retorna pra gente um identificador do processo criado, como se fosse seu endereço. Então vamos salvar o retorno de spawn na variável gato. Agora é só enviar a mensagem.

O gato precisa saber como receber essa mensagem. Para isso a gente definiu o bloco receive. Funciona assim: o gato vai olhar dentro da caixa de correio e decidir o que é importante. Ou seja, para quais mensagens ele quer fazer alguma coisa.

# gato.exs
defmodule Gato do
  def criar do
    receive do
      :e_ai_beleza -> IO.puts("De boas")
    end
  end
end

# Cria um gato
gato = spawn(Gato, :criar, [])

# Manda mensagem
send(gato, :e_ai_beleza)

# Resultado:
# "De boas"

Respondendo de volta

Nosso código tem um problema. Imagine o IO.puts("De boas") como se o gato tivesse falado isso. Mas vocês estão em suas próprias casas, lembra? Então você não ouviu a resposta dele. Como os processos se comunicam com mensagens, ele teria que te mandar uma mensagem de volta.

Ainda bem que você já sabe como enviar uma mensagem. É só fazer o gato responder com send(rato, :de_boas) e está tudo certo! Entretanto como o gato vai saber que a mensagem veio do rato? Para fazer isso, vamos falar na mensagem quem foi o remetente. Temos que mudar o receive do gato para se importar com mensagens que seguem o padrão {:e_ai_beleza, remetente}. Assim ele pode responder para a pessoa certa com send(remetente, :de_boas). Fica assim:

receive do
  {:e_ai_beleza, remetente} -> send(remetente, :de_boas)
end

Agora o rato precisa se identificar para mandar a mensagem send(gato, {:e_ai_beleza, rato}). Lembre-se que o rato é o processo atual. Para identificar o processo atual no código usamos a função self/0. É como se estivéssemos pegando nosso próprio endereço. Então salvamos seu retorno em uma variável rato = self().

# Esse é você
rato = self()

# Manda mensagem
send(gato, {:e_ai_beleza, rato})

Está quase tudo pronto. Só precisamos ver na caixa de correio do rato a mensagem que o gato enviou e decidir o que fazer. O código todo ficaria assim:

# gato.exs
defmodule Gato do
  def criar do
    receive do
      {:e_ai_beleza, remetente} -> send(remetente, :de_boas)
    end
  end
end

# Esse é você
rato = self()

# Cria um gato
gato = spawn(Gato, :criar, [])

# Manda mensagem
send(gato, {:e_ai_beleza, rato})

receive do
  :de_boas -> IO.puts("Massa!")
end

# Resultado
# Massa!

Processo Temporário

É possível verificar se um processo está vivo com a função Process.alive?/1. Vamos executar o mesmo código acima mas ver quando o processo gato está vivo adicionando IO.puts("Gato está vivo? #{Process.alive?(gato)}").

defmodule Gato do
  def criar do
    receive do
      {:e_ai_beleza, remetente} -> send(remetente, :de_boas)
    end
  end
end

# Esse é você
rato = self()

# Cria um gato
gato = spawn(Gato, :criar, [])

IO.puts("Gato está vivo? #{Process.alive?(gato)}")

# Manda mensagem
send(gato, {:e_ai_beleza, rato})

receive do
  :de_boas -> IO.puts("Massa!")
end

IO.puts("Gato está vivo? #{Process.alive?(gato)}")

# Resultado
# Gato está vivo? true
# Massa!
# Gato está vivo? false

Podemos ver que o processo estava vivo, mas depois de responder ele morreu. Por que isso aconteceu?

Para entender o que aconteceu vamos olhar a função criar. Aqui a gente definiu um bloco receive. Como o rato recebeu a mensagem de volta, a comunicação está correta. Mas o que acontece depois que o gato responde? Simplesmente não acontece mais nada no processo gato. Sendo assim, ele não precisa mais existir e o processo morre!

def criar do
  receive do
    {:e_ai_beleza, remetente} -> send(remetente, :de_boas)
  end
end

Processo Permanente

Para manter o processo vivo vamos dizer que ele não responde apenas uma mensagem. Ele vai ficar checando das mensagens e respondendo. Podemos fazer isso definindo a função checar_mensagens/0 e passar o bloco receive para ela.

def criar do
  checar_mensagens()
end

def checar_mensagens do
  receive do
    {:e_ai_beleza, remetente} -> send(remetente, :de_boas)
  end

  checar_mensagens()
end

Dessa forma a única coisa que a função criar faz é dizer para o gato checar as mensagens. Agora olhe a última linha de checar_mensagens/0. Ela chama a si mesma! Ou seja sempre que acabar ela volta para o começo. É uma função recursiva. Dessa forma o gato checa as mensagens para sempre e não morre. O código todo fica assim:

defmodule Gato do
  def criar do
    checar_mensagens()
  end

  def checar_mensagens do
    receive do
      {:e_ai_beleza, remetente} -> send(remetente, :de_boas)
    end

    checar_mensagens()
  end
end

# Esse é você
rato = self()

# Cria um gato
gato = spawn(Gato, :criar, [])

IO.puts("Gato está vivo? #{Process.alive?(gato)}")

# Manda mensagem
send(gato, {:e_ai_beleza, rato})

receive do
  :de_boas -> IO.puts("Massa!")
end

IO.puts("Gato está vivo? #{Process.alive?(gato)}")

# Resultado
# Gato está vivo? true
# Massa!
# Gato está vivo? true

Conclusão

Aqui você aprendeu o básico de como criar processos com spawn. Como eles enviam mensagens com send/2 e recebem mensagens com receive. Você viu um pouco sobre como um processo pode morrer e como mantê-lo vivo. E o melhor de tudo, que gatos e ratos podem ser amigos no fim das contas!