elixir :poolboy example

application.ex

defmodule PoolboyApp.Application do
  # See https://hexdocs.pm/elixir/Application.html
  # for more information on OTP Applications
  @moduledoc false

  use Application

  defp poolboy_config do
    [
      {:name, {:local, :worker}},
      {:worker_module, PoolboyApp.Worker},
      {:size, 5},
      {:max_overflow, 2},
      # {:strategy, :lifo}, # :lifo :fifo, defualt is :lifo
    ]
  end

  def start(_type, _args) do
    # List all child processes to be supervised
    children = [
      # Starts a worker by calling: PoolboyApp.Worker.start_link(arg)
      # {PoolboyApp.Worker, arg},
      :poolboy.child_spec(:worker, poolboy_config())
    ]

    # See https://hexdocs.pm/elixir/Supervisor.html
    # for other strategies and supported options
    opts = [strategy: :one_for_one, name: PoolboyApp.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

test.ex

defmodule PoolboyApp.Test do
  @timeout 60000

  def start(n) do
    1..n
    |> Enum.map(fn i -> async_call_squre_root(i) end)
    |> Enum.each(fn task -> await_and_inspect(task) end)
  end

  defp async_call_squre_root(i) do
    Task.async(fn ->
      # transaction(PoolName, Function, timeout \\ :infinite)
      :poolboy.transaction(
        :worker,
        fn pid -> GenServer.call(pid, {:square_root, i}) end,
        @timeout
      )
    end)
  end

  defp await_and_inspect(task) do
    task
    |> Task.await(@timeout)
    |> IO.inspect()
  end

end

worker.ex

defmodule PoolboyApp.Worker do
  use GenServer

  def start_link(_) do
    # GenServer.start_link(module, args, options \\ [])
    GenServer.start_link(__MODULE__, [], [])
  end

  def init(_) do
    {:ok, nil}
  end

  def handle_call({:square_root, x}, _from, state) do
    IO.puts(
      "processes #{inspect(self())} calculating square root of #{x}")
    :timer.sleep(1000)
    {:reply, :math.sqrt(x), state}
  end

end