Send_later to Agent

denna

I like to make use of Process.send_later to send a message to an Agent.
When I understand this tutorial right than one needs to implement handle_info to handle the message send by send_after. Agent doesn’t implement handle_info. Only gen_server does so.

As an example one could use the counter from the documentation:

defmodule Counter do
  use Agent

  def start_link(initial_value) do
    Agent.start_link(fn -> initial_value end, name: __MODULE__)
  end

  def value do
    Agent.get(__MODULE__, & &1)
  end

  def increment do
    Agent.update(__MODULE__, &(&1 + 1))
  end
end

Counter.start_link(1)

Process.send_after(Counter,:increment,1000)

15 comments

#agent #beginner #process

0 2294 15

2021-04-18 22:36:32 UTC

First 10 of 15 Posts

hauleth

Just don’t use Agent if you want to handle your own messages.

Post #1

denna

Actually i want to use send_after from another process.

Post #2

amnu3387

I think that’s what @hauleth is saying, if you need to receive messages on the Agent, then it’s not the right thing to use.

There’s several abstractions already written in both erlang and elixir and they all have a sort of “utility field”.

Agents are for keeping/retrieving state. GenServers are generic server interfaces, so they’re modelled as a behaviour that you can customise to handle your own message needs.

They can also do a slight impersonation of a state machine, but if you need actual state machine semantics, timeouts, stepped flows, etc then probably it’s easier to write a proper gen_statem which is an abstracted behaviour for that exact thing instead of shoehorning that into a gen_server, Tasks are for doing something and exiting, and so on.

If you need your Agent to receive messages and handle them then you’re either looking at gen_server or writing your own simple process to handle it (usually you’ll want the gen_server as its interface handles a lot of things for you)

Post #3

denna

I still think that Agent is quite efficient (in terms of lines to be written compared to GenServer) and i think it makes sense to update its state in the future. I solved my need for now using :timer.apply_after/4.
In terms of processing power its not efficient.
The Erlang documentation highlights that Process.send_after is more efficient than :timer.apply_after/4 . I guess that GenServer is more efficient than Agent. Am I right about this?

Post #4

hauleth

Agent is thin wrapper over GenServer, so the performance should be similar.

And your example using GenServer will not be much more complex:

defmodule Counter do
  use GenServer

  def start_link(initial_value) do
    GenServer.start_link(__MODULE__, initial_value, name: __MODULE__)
  end

  def value, do: GenServer.call(__MODULE__, :get)
  def increment, do: GenServer.call(__MODULE__, :inc)

  @impl true
  def init(value), do: {:ok, value}

  @impl true
  def handle_call(:inc, state), do: {:reply, :ok, state + 1}
  def handle_call(:get, state), do: {:reply, state, state}
end

Post #5

denna

But doesn’t sending functions as messages makes sending more expensive?

Post #6

hauleth

You send functions as a messages in Agent case. So if it is indeed true (I highly doubt that if these messages are on local machine) then GenServer will be more performant one, as it send just simple atoms.

Post #7

kokolegorille

Many don’t use Agent (and prefer GenServer), and many don’t use :timer library (and prefer Process.send_after, or similar)

This is something You might learn from experience.

Post #8

derek-zhou

Does Process.send_after/3 work if the calling process quit before the timeout? If I want to do something similar, I’d cast a delay_update message to my gen_server, and within my gen_server I will Process.send_after/3 to self() to postpone the update. It involves 2 messages but it feels safer.

Post #9