Creating Named GenServers in Elixir Using Registry

In this guide, we’ll explore how to use Registry along with a Dynamic Supervisor to create named GenServers.


Let's start by creating a simple GenServer

defmodule Server do

  use GenServer



  def start_link({init_arg, name}) do

    GenServer.start_link(__MODULE__, init_arg, name: name)

  end



  @impl true

  def init(arg) do

    {:ok, arg}

  end



  def state(name) do

    GenServer.call(name, :state)

  end



  @impl true

  def handle_call(:state, _from, state) do

    {:reply, state, state}

  end

end

{:module, Server, <<70, 79, 82, 49, 0, 0, 19, ...>>, {:handle_call, 3}}

Now, we can start a new instance of the GenServer and attempt to retrieve its current state.

initial_value = 123

server_name = :server

Server.start_link({initial_value, server_name})

{:ok, #PID<0.160.0>}

Server.state(:server)

123

Note that the name cannot be a string:

Server.start_link({123, "server"})

Dynamic Supervisor

With our GenServer ready, the next step is to create a Dynamic Supervisor that will manage and start our GenServers.

defmodule DSupervisor do

  use DynamicSupervisor



  def start_link(init_arg) do

    DynamicSupervisor.start_link(__MODULE__, init_arg, name: __MODULE__)

  end



  def init(_init_arg) do

    DynamicSupervisor.init(strategy: :one_for_one)

  end



  def start_server(initial_value, name) do    

    DynamicSupervisor.start_child(__MODULE__, {Server, {initial_value, name}})

  end

end

{:module, DSupervisor, <<70, 79, 82, 49, 0, 0, 10, ...>>, {:start_server, 2}}

Now, we can start the Dynamic Supervisor and use it to launch another GenServer.

DSupervisor.start_link(1)

{:ok, #PID<0.170.0>}

DSupervisor.start_server(321, :test)

{:ok, #PID<0.171.0>}

Server.state(:server) |> IO.inspect()

Server.state(:test)

123

321

So, what’s the issue?

Naming a GenServer using atoms is generally not a problem. However, if your application dynamically creates GenServers with different names—such as when users start GenServers by creating a new match in a browser game or starting a new chat room—this approach can lead to problems.

Atoms are not garbage collected, and dynamically generating them as names for GenServers increases memory usage over time. Eventually, this can exhaust the atom table and cause the application to fail.

To solve this, we need a way to associate a custom name with a GenServer while storing its PID. Fortunately, Elixir provides a built-in solution for this: the Registry.

Registry.start_link(keys: :unique, name: Registry)

{:ok, #PID<0.172.0>}

Now we can use the Registry to register process names.

name = {:via, Registry, {Registry, "cool_name"}}

DSupervisor.start_server(42, name)

{:ok, #PID<0.174.0>}

Server.state(name)

42

The Registry allows us to fetch the PID of a process using the lookup function, which we will use in this guide to terminate a server.

[{pid, _value}] = Registry.lookup(Registry, "cool_name")

 DynamicSupervisor.terminate_child(DSupervisor, pid)

:ok

Registry will monitor the GenServer and automatically remove the registration when the GenServer is terminated.

Server.state(name)

By using the Registry, we can safely register and manage names for GenServers with ease, ensuring that each process is uniquely identifiable and accessible. The Registry also helps by automatically cleaning up registrations when a GenServer is terminated, preventing memory leaks and improving the efficiency of your application.

With this approach, you can build scalable, maintainable systems where users can dynamically create and interact with multiple GenServers without worrying about the limitations of atom-based naming.

A few noteworthy details

When starting the Registry or the Dynamic Supervisor, the

 we use sometimes look like a module, but they are just atoms, they could be named differently, like



 ```:registry```



 or



 ```:supervisor```











```elixir

Registry.start_link(keys: :unique, name: :registry)

name = {:via, Registry, {:registry, "another_name"}}

DSupervisor.start_server(42, name)

{:ok, #PID<0.5230.0>}

Interacting with the Registry could be encapsulated within the GenServer, making it easier to work with.

defp registry_name(name), do: {:via, Registry, {:registry, name}}



def start_link({init_arg, name}) do

  GenServer.start_link(__MODULE__, init_arg, name: registry_name(name))

end



def state(name) do

  GenServer.call(registry_name(name), :state)

end