Language: Elixir / Erlang · Versions: Elixir 1.17.3 / Erlang/OTP 27
The problem
I have a GenServer that handles a handle_call by delegating work or taking longer than the caller's timeout (GenServer.call(pid, :work, 100)), and the caller wraps GenServer.call in a try / catch :exit, _ -> :timeout end. In older OTP versions, a late reply {ref, result} from the server would sit in the caller's mailbox forever (and could accidentally match a wildcard receive). In OTP 24–27, GenServer.call uses process alias references (monitor(:process, pid, alias: :reply_demonitor)). However, if the server spawns a Task.async inside handle_Info / handle_call and the GenServer catches a timeout from Task.yield(task, 100) without calling Task.shutdown(task, :brutal_kill), the late {ref, result} and {:DOWN, ref, ...} messages hit the GenServer's handle_info/2 and crash the GenServer with FunctionClauseError!
Minimal example
defmodule WorkerServer do
use GenServer
def init(state), do: {:ok, state}
def handle_call(:compute, _from, state) do
task = Task.async(fn ->
Process.sleep(200)
:late_answer
end)
case Task.yield(task, 50) do
{:ok, res} -> {:reply, res, state}
nil ->
# Forgot `Task.shutdown(task, :brutal_kill)`!
{:reply, {:error, :timeout}, state}
end
end
end
Expected
When Task.yield(task, 50) returns nil, the GenServer replies {:error, :timeout} and continues running cleanly.
What happens instead
150ms later, the spawned Task finishes and sends {ref, :late_answer} followed by {:DOWN, ref, :process, pid, :normal} to WorkerServer's mailbox. Because WorkerServer has no catch-all handle_info/2 for stray task replies, it crashes with ** (FunctionClauseError) no function clause matching in WorkerServer.handle_info/2!
Why does GenServer.call in OTP 27 avoid late-reply mailbox pollution automatically (via :reply_demonitor aliases), whereas Task.async + Task.yield still requires explicit Task.shutdown, and how does Task.Supervisor.async_nolink change this?
The crash in your example doesn't happen as described. Two details differ from what you wrote. I haven't run any of this; it comes from the Elixir and OTP docs as I remember them.
1. use GenServer defines a default handle_info/2. WorkerServer defines no handle_info/2, so the default one handles the stray {ref, :late_answer} and {:DOWN, ...}. It logs an error about an unexpected message and returns {:noreply, state}. You get log noise but no FunctionClauseError. That error only appears if you define your own handle_info/2 clauses and leave out a catch-all. A catch-all for stray task messages looks like this:
def handle_info({ref, _late}, state) when is_reference(ref) do
Process.demonitor(ref, [:flush])
{:noreply, state}
end
def handle_info({:DOWN, _ref, :process, _pid, _reason}, state), do: {:noreply, state}
2. The real hazard is the link, not the mailbox. Task.async links the task to the GenServer. If the abandoned task later crashes, the exit signal kills the GenServer. A task that finishes normally does no harm.
The minimal fix
case Task.yield(task, 50) || Task.shutdown(task, :brutal_kill) do
{:ok, res} -> {:reply, res, state}
{:exit, reason} -> {:reply, {:error, reason}, state}
nil -> {:reply, {:error, :timeout}, state}
end
Task.shutdown/2 unlinks the task, kills it, demonitors with flush, and drops the reply if one arrived in the meantime. If the reply had already arrived, it returns {:ok, res}, so the || form is race-free. Task.yield/2 alone does none of this. On timeout it leaves the monitor, the link and the pending reply in place.
Why GenServer.call is different
Since OTP 24, gen monitors the server with an alias (erlang:monitor(process, Pid, [{alias, demonitor}]); the option is spelled that way for monitor/3). When the call times out, the caller demonitors, which deactivates the alias, and the VM silently drops any later reply sent to it. The cleanup is built into the call.
Task sets up a similar monitor and alias, but yield has no cleanup step. It returns nil and keeps waiting for a later yield or await. Only Task.shutdown (or a successful yield/await) does the demonitor and flush.
Task.Supervisor.async_nolink
task = Task.Supervisor.async_nolink(MyApp.TaskSup, fn -> ... end)
This removes the link, so a crashing task no longer takes the GenServer down. It does not remove the message protocol. You still get {ref, result} or {:DOWN, ...}, and you still call Task.yield/Task.shutdown or handle those messages. It is the usual choice inside a GenServer.
If you actually saw a FunctionClauseError, paste the full stack trace and your complete handle_info clauses. That would show which message hit which function, and I'd expect a custom clause without a catch-all.