Conveniences for spawning and awaiting for tasks.

Tasks are processes meant to execute one particular action throughout their life-cycle, often with little or no communication with other processes. The most common use case for tasks is to compute a value asynchronously:

task = Task.async(fn -> do_some_work() end)
res  = do_some_other_work()
res + Task.await(task)

Tasks spawned with async can be awaited on by its caller process (and only its caller) as shown in the example above. They are implemented by spawning a process that sends a message to the caller once the given computation is performed.

Besides async/1 and await/2, tasks can also be started as part of supervision trees and dynamically spawned in remote nodes. We will explore all three scenarios next.

async and await

The most common way to spawn a task is with Task.async/1. A new process will be created, linked and monitored by the caller. Once the task action finishes, a message will be sent to the caller with the result.

Task.await/2 is used to read the message sent by the task. On await, Elixir will also setup a monitor to verify if the process exited for any abnormal reason (or in case exits are being trapped by the caller).

Supervised tasks

It is also possible to spawn a task inside a supervision tree with start_link/1 and start_link/3:

Task.start_link(fn -> IO.puts "ok" end)

Such tasks can be mounted in your supervision tree as:

import Supervisor.Spec

children = [
  worker(Task, [fn -> IO.puts "ok" end])
]

Since these tasks are supervised and not directly linked to the caller, they cannot be awaited on. Note start_link/1, unlike async/1, returns {:ok, pid} (which is the result expected by supervision trees).

Supervision trees

The Task.Supervisor module allows developers to start supervisors that dynamically supervise tasks:

{:ok, pid} = Task.Supervisor.start_link()
Task.Supervisor.async(pid, MyMod, :my_fun, [arg1, arg2, arg3])

Task.Supervisor also makes it possible to spawn tasks in remote nodes as long as the supervisor is registered locally or globally:

# In the remote node
Task.Supervisor.start_link(name: :tasks_sup)

# In the client
Task.Supervisor.async({:tasks_sup, :remote@local}, MyMod, :my_fun, [arg1, arg2, arg3])

Task.Supervisor is more often started in your supervision tree as:

import Supervisor.Spec

children = [
  supervisor(Task.Supervisor, [[name: :tasks_sup]])
]

Note that, when working with distributed tasks, one should use the async/3 API, that expects explicit module, function and arguments, instead of async/1 that works with anonymous functions. That’s because the anonymous function API expects the same module version to exist on all involved nodes. Check the Agent module documentation for more information on distributed processes, as the limitations described in the agents documentation apply to the whole ecosystem.

Finally, check Task.Supervisor for other operations supported by the Task supervisor.