Scaling Concurrency Without Getting Burned

We all know Elixir is fast and scalable, but knowing how to leverage its strengths can be the difference between a fast program and one unrivaled by other platforms. Whether you're reaching for Tasks and GenServers, or wrangling data with Ecto, understanding subtle nuances of each tool is the key to avoiding bottlenecks and writing efficient applications.

Starting from real-world scenarios, we'll explore various OTP tricks and concurrency patterns to drive maximum performance. Along the way, we'll see how features built-in to Elixir and OTP can apply to applications from small to large. We'll also navigate the unexpected pitfalls that come with cheap concurrency and how to safeguard from each trap.

Whether you're an intermediate or seasoned Elixir developer, you'll leave with some new performance tricks and a mental model for writing highly concurrent applications.

Transcript

13. def handle_call({:fetch_block, block_number}, state) do # Fetch block data from third-party API block_data = fetch_block(block_number) {:reply, block_data, state} end 13
16. task = Task.async(fn -> fetch_block(1_000_000) end) Task.await(task) # {:ok, %Block{number: 1_000_000, ...}} 16
17. Task.async_stream Task.yield_many 17
18. block_range_batches |> Task.async_stream(&fetch_blocks(&1)) |> Task.yield_many() 18
21. block_range_batches |> Task.async_stream( &fetch_blocks(&1), max_concurrency: 4 ) |> Task.yield_many() 21
36. def init(_) do state = build_state() send(self(), :start_task) {:ok, state} end def handle_info(:start_task, state) %Task{ref: ref} = task = Task.async(fn -> do_expensive_work(state) end) Task.run(task) {:noreply, Map.put(state, :task_ref, ref)} end 36
38. def handle_info({ref, expensive_work_result}, %{task_ref: ref} = state) # Flush messages related to the monitor Process.demonitor(ref, [:flush]) # Do something with the result process_result(expensive_work_result) send(self(), :start_task) {:noreply, %{state | task_ref: nil}} end 38
42. children = [ {Task.Supervisor, name: BlockScout.TaskSupervisor} ] Supervisor.start_link(children, strategy: :one_for_one) 42
43. def handle_info(:start_task, state) do %Task{ref: ref} = Task.Supervisor.async_nolink( BlockScout.TaskSupervisor, fn -> do_expensive_work(state) end ) {:noreply, Map.put(state, :task_ref, ref)} end 43
45. def handle_info({ref, expensive_work_result}, %{task_ref: ref} = state) # Flush messages related to the monitor Process.demonitor(ref, [:flush]) # Do something with the result process_result(expensive_work_result) send(self(), :start_task) {:noreply, %{state | task_ref: nil}} end 45
47. def handle_info({:DOWN, ref, :process, pid, reason}, %{task_ref: ref} = state) do # Decide how to respond to a failure handle_process_failure() {:noreply, %{state | task_ref: nil} end 47
51. Repo.insert 51
52. Ecto.Repo.insert_all/3 52
53. blocks = [%{...}, %{...}, ...] Repo.insert_all(Block, blocks, []) 53
55. blocks = [%{...}, %{...}, ...] Repo.insert_all( Block, blocks on_conflict: :replace_all, conflict_target: :number ) 55
58. Ecto.Repo.stream/2 58
59. query = unfetched_address_balances_query() reducer = fn (item, list) -> [item | list] end initial = [] Repo.transaction( fn -> query |> Repo.stream() |> Enum.reduce([], reducer) end ) 59
60. query = unfetched_address_balances_query() reducer = fn (item, list) -> [item | list] end initial = [] Repo.transaction( fn -> query |> Repo.stream(timeout: :infinity) |> Enum.reduce([], reducer) end, timeout: :infinity ) 60
62. defmodule BlockScout.MarketRates.Cache do use GenServer # ... def handle_info(:refresh_rates, _state) do rates = fetch_rates() {:noreply, rates} end def handle_call({:fetch_ticker, ticker}, state) do {:reply, Map.get(state, :ticker), state} end end 62
65. def init(_) do :ets.new( :market_rates_cache, [:set, :named_table, :public, read_concurrency: true, write_concurrency: true] ) send(self(), :refresh_rates) {:ok, %{}} end 65
66. def handle_info(:refresh_rates, state) do rates = fetch_rates() insert_into_ets(data) {:noreply, state} end def all_tickers do :ets.tab2list(:my_app_cache) end def fetch_ticker(ricker) do case :ets.lookup(:market_rates_cache, ticker) do [item] -> {:ok, item} _ -> {:error, :not_found} end end 66
69. Phoenix.PubSub 69
70. children = [ # ... {Registry, keys: :duplicate, name: Blockchain.Events} ] 70
71. Registry.register(Blockchain.Events, :new_block, []) 71
72. Registry.dispatch(Blockchain.Events, :new_block, fn entries -> for {subscriber_pid, _registered_val} <- entries do send(subscriber_pid, {:new_block, block}) end end) 72