0Pricing
Elixir & Phoenix: Scalable Backend Development · Pelajaran

Pekerjaan Konkuren dengan Task dan Agent

Jalankan kode secara konkuren dan kelola status bersama yang sederhana menggunakan abstraksi Task dan Agent yang dibangun di atas OTP.

Pekerjaan Konkuren dengan Task dan Agent adalah pelajaran Elixir & Phoenix: Scalable Backend Development gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Elixir & Phoenix: Scalable Backend Development, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Elixir & Phoenix: Scalable Backend Development mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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/await for concurrent work and results
  • Task.async_stream for bounded parallel mapping
  • Agent for simple, safe shared state
  • Pick Task, Agent, or GenServer by how much control you need

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pekerjaan Konkuren dengan Task dan Agent” gratis?

Ya — teks lengkap “Pekerjaan Konkuren dengan Task dan Agent” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Elixir & Phoenix: Scalable Backend Development, upgrade ke CoddyKit PRO. Kursus Elixir & Phoenix: Scalable Backend Development mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pekerjaan Konkuren dengan Task dan Agent”?

Jalankan kode secara konkuren dan kelola status bersama yang sederhana menggunakan abstraksi Task dan Agent yang dibangun di atas OTP. Kamu berlatih Elixir & Phoenix: Scalable Backend Development dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Elixir & Phoenix: Scalable Backend Development?

Tidak diperlukan pengalaman sebelumnya. Elixir & Phoenix: Scalable Backend Development di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Pekerjaan Konkuren dengan Task dan Agent” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Elixir & Phoenix: Scalable Backend Development ini?

Ya. Setiap pelajaran Elixir & Phoenix: Scalable Backend Development menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Proses Elixir dan Pengiriman Pesan
  2. Menerapkan Perilaku GenServer
  3. Supervisor dan Struktur Aplikasi
  4. Pekerjaan Konkuren dengan Task dan Agent
← Kembali ke Elixir & Phoenix: Scalable Backend Development