Processes in Elixir

Update

git pull

git stash ; git pull - if just pull doesn’t work

Pretty please disable AI addons from your editor

Basics recall

Printing on console

msg = "hello"
## inspect is kind of `printf` or `console.log` in other languages
IO.inspect(msg)
IO.inspect(msg, label: "this is label added before msg")

Creating lambda function

lambda = fn -> 12 end
lambda.()

Processes

Erlang and Elixir processes are:

• lightweight (grow and shrink dynamically)
• with small memory footprint,
• fast to create and terminate,
• the scheduling overhead is low.

The theory behind a process is well explained in this blog post: https://www.erlang-solutions.com/blog/understanding-processes-for-elixir-developers/

Staring new process

Use function self/0 to determine the PID (process ID) of current process.

self()

Staring a new process can be done using spawn/1 function. After spawning, new process is completly unrelated to the process was spawned by. There is no parent-child relation in oposition what you can see eg in Linux OS.

IO.inspect(self(), label: "I am parent process")
execute_fun = fn -> IO.inspect(self(), label: "I am child process") end
spawn(execute_fun)

A process terminates as soon as its starting function finishes execution.

pid = spawn(fn -> 
        IO.inspect("starting a process")
        Process.sleep(1000) 
        IO.inspect("last line in a process function")
      end)
# process is alive
Process.alive?(pid) |> IO.inspect(label: "process alive?")
# waits after function completes its execution
Process.sleep(1200)
# process is terminated
Process.alive?(pid) |> IO.inspect(label: "process alive?")

A process can be killed during calculations by seding a :shutdown signal via Process.exit/2

pid = spawn(fn -> 
        IO.inspect("starting a process")
        Process.sleep(1000) 
        # that line won't execute
        IO.inspect("last line in a process function")
      end)
# process is alive
Process.alive?(pid) |> IO.inspect(label: "process alive?")
# waits after function completes its execution
Process.exit(pid, :shutdown)
# process is terminated
Process.alive?(pid) |> IO.inspect(label: "process alive?")

Get basic info about process using Erlang function process_info/0.

pid = spawn(fn -> Process.sleep(1000) end)
pid |> Process.info()

Comunication

We can send messages to a process with send/2 and receive them with receive/1: receive is blocking operation that waits for a message, while send returns immediately

pid = spawn(fn ->
    # receiving message
    receive do
      msg -> IO.inspect(msg, label: "I have received")
    end
end)

# sending a message to unnamed process
Process.alive?(pid) |> IO.inspect(label: "process alive?")
send(pid, "Hello")
Process.sleep(100)
Process.alive?(pid) |> IO.inspect(label: "process alive?")

Quick recall of pattern matching

msg = {:greetings, "hello"}
# msg = {:question, "how are u?"}
case msg do
    {:question, msg} -> msg
    {:greetings, msg} -> msg
end    

Comunication cont.

When selectivly waiting the message may never arrive, therefore timeout part is added to the receive block:

pid = spawn(fn -> 
    receive do
      {:greetings, content} -> IO.inspect(content, label: "I have received")
    after
      # timeout is in miliseconds
      3000 -> IO.inspect(:timeout, label: "I have received")
    end
end)

send(pid, {:question, "How are you?"})

Messages can be pattern-matched, and if a message doesn’t match any pattern, it stays in the process’s message queue.

pid = spawn(fn ->
    receive do
      {:greetings, content} -> IO.inspect(content, label: "I have received")
     after 
       500 -> :ok 
    end

    ## This will never happen without after clause
    IO.inspect("previous line wait's for {:greetings, ...} msg -  so the log statement won't be executed.")   
end)

 pid |> Process.info(:message_queue_len) |> IO.inspect()
 send(pid, {:question, "How are you?"})
 pid |> Process.info(:message_queue_len) |> IO.inspect()
 Process.sleep(200)
 Process.alive?(pid) |> IO.inspect(label: "is alive?")
 Process.sleep(500)
 Process.alive?(pid) |> IO.inspect(label: "is alive?")

Naming processes

Processe can be named via Process.register/2 so that we do not have to remember their PIDs and we can reffer to them from anywhere in BEAM (Erlang VM).

execute_fun = fn ->
  receive do
    msg -> IO.inspect(msg, label: "Krzys received")
  end
end

pid = spawn(execute_fun)
Process.register(pid, :krzys)

# wait a bit for process registration
Process.sleep(300)

send(:krzys, "Hello")

Getting a pid of named process

spawn(fn ->
    IO.inspect(self(), label: "self pid")
    Process.register(self(), :hello)
    Process.sleep(300)
end)
Process.sleep(100)
Process.whereis(:hello) |> IO.inspect(label: ":hello pid got by whereis")

Communication cont.

We can use selective receives to ensure that messages are consumed in particular order:

pid = spawn(fn ->
    receive do
      {:greetings, content} ->
        IO.inspect(content, label: "I have received")
    end

    receive do
      {:question, question} ->
        IO.inspect(question, label: "I have received")
    end
end)
send(pid, {:question, "How are you?"})
Process.sleep(3000)
send(pid, {:greetings, "Hello"})

We can match against multiple patterns in a selective receive, but keep in mind that each receive still waits for only one message at a time.

pid = spawn(fn -> 
    receive do
      {:greetings, content} ->
        IO.inspect(content, label: "I have received")
      {:question, question} ->
        IO.inspect(question, label: "I have received")
    end
end)
send(pid, {:question, "How are you?"})
Process.sleep(3000)
send(pid, {:greetings, "Hello"})

Exercise 1 - 5

Please go to ElixirSchool2025/class2/exercises/lib
and try to solve exercises 1 - 5

Tu run tests please run mix test --only test1 command in ElixirSchool2025/class2/exercises directory

Monitors

Monitor is a way of observing how some other process is doing. When process A monitors process B, and process B crushes, process A gets notified by receiving a message: {:DOWN, ref, :process, pidB, reason}. Monitors are unidrectional which means that if A monitors B, B does not know it is monitored.

Process can die in either normal or unnormal way. Normal is when it runs out of code do execute, and unnormal is when is crashses, for example by trying to match 2 to value 1.

spawn(fn ->
  Process.register(self(), :B)
  receive do
    :crash -> 1 = 2
    :die_normally -> :ok
  end
end)


# crash scenario
pidA = spawn(fn -> 
    Process.monitor(:B)
    send(:B, :crash)

    receive do
      msg -> IO.inspect(msg, label: "A received")
    after
      0 -> :ok
    end
end)

spawn(fn ->
  Process.register(self(), :B)
  receive do
    :crash -> 1 = 2
    :die_normally -> :ok
  end
end)

# normal termination scenario
pidA = spawn(fn -> 
    Process.monitor(:B)
    send(:B, :die_normally)

    receive do
      msg -> IO.inspect(msg, label: "A received")
    after
      0 -> :ok
    end
end)

## Cleanup
for proc <- [:A, :B] do
  proc
  |> Process.whereis()
  |> (fn
        nil -> :ok
        pid -> Process.exit(pid, :kill)
      end).()
end

Links

When two processes can be linked to each other. If one of the participants of a link terminates, it will send an exit signal to the other participant. The exit signal will contain the exit reason of the terminated participant. Links are bidirectional.

IO.inspect(self(), label: "I am")

a =
  spawn(fn ->
    Process.register(self(), :A)
    IO.inspect({:A, self()}, label: "I am")

    receive do
      :crash -> 1 = 2
      :die_normally -> :ok
    end
  end)

Process.sleep(100)

b =
  spawn(fn ->
    Process.register(self(), :B)
    IO.inspect({:B, self()}, label: "I am")

    Process.link(a)

    receive do
      _ -> :ok
    end
  end)

# Process.sleep(100)
# c = spawn(fn ->
#   Process.register(self(), C)
#   IO.inspect({C, self()}, label: "I am")
#
#   Process.link(b)
#   receive do
#     _ -> :ok
#   end
# end)

Process.sleep(100)

send(:A, :crash)
# send(:A, :die_normally)

Process.sleep(100)

IO.inspect(Process.alive?(a), label: "Final A alive?")
IO.inspect(Process.alive?(b), label: "Final B alive?")
# IO.inspect(Process.alive?(c), label: "Final C alive?")

There is an option set a special process flag to trap exits. When trap_exit process flag is set to true, instread of receiving exit signal a process receives a message - {:EXIT, pid, reason}

IO.inspect(self(), label: "I am")

a =
  spawn(fn ->
    Process.register(self(), :A)
    IO.inspect({:A, self()}, label: "I am")

    receive do
      :crash -> 1 = 2
      :die_normally -> :ok
    end
  end)

Process.sleep(100)

b =
  spawn(fn ->
    Process.register(self(), :B)
    Process.flag(:trap_exit, true)
    IO.inspect({:B, self()}, label: "I am")

    :A
    |> Process.whereis()
    |> Process.link()

    receive do
      msg -> IO.inspect(msg, label: "The trap exit messge")
    end

    receive do
      _ -> :ok
    end
  end)

Process.sleep(100)

send(:A, :crash)

Process.sleep(100)

IO.inspect(Process.alive?(a), label: "Final A alive?")
IO.inspect(Process.alive?(b), label: "Final B alive?")

## Cleanup
for proc <- [:A, :B, :C] do
  proc
  |> Process.whereis()
  |> (fn
        nil -> :ok
        pid -> Process.exit(pid, :kill)
      end).()
end

Exercise 6 - 9

Please go to ElixirSchool2025/class2/exercises/lib
and try to solve exercises 6 - 9

Last but not least

Please visit https://github.com/LKlemens/ElixirSchool2025

My email

klemens.lukaszczyk@erlang-solutions.com