Trabajo concurrente con Task y Agent
Ejecute código de forma concurrente y gestione estados compartidos sencillos mediante las abstracciones Task y Agent, construidas sobre OTP.
Trabajo concurrente con Task y Agent es una lección gratuita de Elixir & Phoenix: Scalable Backend Development en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Elixir & Phoenix: Scalable Backend Development, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Elixir & Phoenix: Scalable Backend Development incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
Beyond Raw spawn
You can start processes with spawn, but OTP gives higher-level tools. Task runs concurrent work and collects results cleanly.
Fire-and-Forget Tasks
Task.start/1 runs a function in a new process when you do not need the result.
Task.start(fn -> IO.puts("running in background") end)Async and Await
Task.async/1 starts work and returns a struct; Task.await/1 blocks until the result is ready.
task = Task.async(fn -> 2 + 2 end)
result = Task.await(task)
IO.inspect(result)Running Tasks in Parallel
Start several tasks, then await them all. The total time is roughly the slowest task, not the sum.
tasks = Enum.map(1..3, fn n ->
Task.async(fn -> n * n end)
end)
IO.inspect(Enum.map(tasks, &Task.await/1))Task.await_many
Task.await_many/1 waits for a list of tasks and returns their results in order.
tasks = for n <- 1..3, do: Task.async(fn -> n * 10 end)
IO.inspect(Task.await_many(tasks))Timeouts
Task.await/2 takes a timeout in milliseconds (default 5000). If exceeded it exits, signalling the work took too long.
task = Task.async(fn -> :timer.sleep(50); :done end)
IO.inspect(Task.await(task, 1000))Streaming Concurrency
Task.async_stream/3 maps a function over a collection concurrently with a bounded number of workers.
1..5
|> Task.async_stream(fn n -> n * n end)
|> Enum.map(fn {:ok, v} -> v end)
|> IO.inspect()Introducing Agent
An Agent wraps mutable state behind a process, giving simple shared state without writing a full GenServer.
{:ok, pid} = Agent.start_link(fn -> 0 end)
IO.inspect(Agent.get(pid, & &1))Updating Agent State
Agent.update/2 transforms the state; Agent.get/2 reads it. The agent serializes access for safety.
{:ok, pid} = Agent.start_link(fn -> 0 end)
Agent.update(pid, &(&1 + 5))
IO.inspect(Agent.get(pid, & &1))get_and_update
Agent.get_and_update/2 reads and writes atomically, returning a value while changing state.
{:ok, pid} = Agent.start_link(fn -> 10 end)
old = Agent.get_and_update(pid, fn s -> {s, s + 1} end)
IO.inspect({old, Agent.get(pid, & &1)})Task vs Agent vs GenServer
Choose the lightest tool:
- Task for one-off concurrent work
- Agent for simple shared state
- GenServer when you need custom messages and lifecycle
Quick Check
Test your Task knowledge.
Recap
You ran concurrent code with OTP abstractions:
Task.async/awaitfor concurrent work and resultsTask.async_streamfor bounded parallel mappingAgentfor simple, safe shared state- Pick Task, Agent, or GenServer by how much control you need
Preguntas frecuentes
¿La lección «Trabajo concurrente con Task y Agent» es gratis?
Sí — el texto completo de «Trabajo concurrente con Task y Agent» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Elixir & Phoenix: Scalable Backend Development, actualiza a CoddyKit PRO. El curso de Elixir & Phoenix: Scalable Backend Development incluye 4 lecciones en total.
¿Qué aprenderé en «Trabajo concurrente con Task y Agent»?
Ejecute código de forma concurrente y gestione estados compartidos sencillos mediante las abstracciones Task y Agent, construidas sobre OTP. Practicas Elixir & Phoenix: Scalable Backend Development con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Elixir & Phoenix: Scalable Backend Development?
No se requiere experiencia previa. Elixir & Phoenix: Scalable Backend Development en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Trabajo concurrente con Task y Agent»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Elixir & Phoenix: Scalable Backend Development?
Sí. Cada lección de Elixir & Phoenix: Scalable Backend Development incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Procesos y paso de mensajes en Elixir
- Implementación del comportamiento GenServer
- Supervisores y estructura de aplicaciones
- Trabajo concurrente con Task y Agent