Processes / Concurrency

As easy as spawn to runs code specified at undefined time each with a process_id
Only communication is messages between processes
Supervisors often linked to processes and will restart on failure
- Simple wrappers around genserver for state.
- “Generic servers” (processes) that encapsulate state, provide sync and async calls, support code reloading, and more. For ongoing background work
- Asynchronous units of computation that allow spawning a process and potentially retrieving its result at a later time.
DynamicSupervisors - Allow you to dynamically create and restart/supervise agents/genservers like if you need to spin one up per user or event
- Allow strings to map to processes(instead of just atoms)

Spawn

spawn(fn() -> loop(50, 1) end) # loop defined up there
spawn(fn() -> loop(100, 50) end)
spawn(MODULE_NAME, FUNCTION_NAME, [ARGS])#alt

spawn_link(fn() -> :ok end) #spawn_link means if one process exits the other one will too(stops dangling p's)

Message Passing

messages are only one way, so if want response need to recieve
Messages will be put in process mailbox for future use

send(self(), {:french, "Bob"})

# Block until a message is received
receive do 
    {:german, name} -> IO.puts "Guten tag #{name}"
    {:french, name} -> IO.puts "Bonjour #{name}"
    after
    500 -> IO.puts "Time up"
end

Process Investigate

Look at livedashboard or erlang observer or

pid = Process.list |> Enum.random
Process.info(p)
Process.alive?(p)

[
  current_function: {:prim_inet, :accept0, 3},
  initial_ call: {:ranch_acceptor, :loop, 4},
  status: :waiting,
  message_queue_len: 0,
  links: [#PID<0.435.0>],
  dictionary: [],
  trap_exit: false,
  error_handler: :error_handler,
  priority: :normal,
  group_leader: #PID<0.386.0>,
  total_heap_size: 233,
  heap_size: 233,
  stack_size: 14,
  reductions: 36,
  garbage_collection: [
    max_heap_size: %{error_logger: true, kill: true, size: 0},
    min_bin_vheap_size: 46422,
    min_heap_size: 233,
    fullsweep_after: 65535,
    minor_gcs: 0
  ],
  suspending: []
]

Process Monitor

iex> {:ok, pid} = KV.Bucket.start_link([])
{:ok, #PID<0.66.0>}
iex> Process.monitor(pid)
#Reference<0.0.0.551>
iex> Agent.stop(pid)
:ok
iex> flush()
{:DOWN, #Reference<0.0.0.551>, :process, #PID<0.66.0>, :normal}

PreviousTesla NextAgent

Last updated 4 years ago

spawn(fn() -> loop(50, 1) end) # loop defined up there spawn(fn() -> loop(100, 50) end) spawn(MODULE_NAME, FUNCTION_NAME, [ARGS])#alt spawn_link(fn() -> :ok end) #spawn_link means if one process exits the other one will too(stops dangling p's)

send(self(), {:french, "Bob"}) # Block until a message is received receive do {:german, name} -> IO.puts "Guten tag #{name}" {:french, name} -> IO.puts "Bonjour #{name}" after 500 -> IO.puts "Time up" end

Process Investigate

Look at livedashboard or erlang observer or

pid = Process.list |> Enum.random
Process.info(p)
Process.alive?(p)

[
  current_function: {:prim_inet, :accept0, 3},
  initial_ call: {:ranch_acceptor, :loop, 4},
  status: :waiting,
  message_queue_len: 0,
  links: [#PID<0.435.0>],
  dictionary: [],
  trap_exit: false,
  error_handler: :error_handler,
  priority: :normal,
  group_leader: #PID<0.386.0>,
  total_heap_size: 233,
  heap_size: 233,
  stack_size: 14,
  reductions: 36,
  garbage_collection: [
    max_heap_size: %{error_logger: true, kill: true, size: 0},
    min_bin_vheap_size: 46422,
    min_heap_size: 233,
    fullsweep_after: 65535,
    minor_gcs: 0
  ],
  suspending: []
]

iex> {:ok, pid} = KV.Bucket.start_link([]) {:ok, #PID<0.66.0>} iex> Process.monitor(pid) #Reference<0.0.0.551> iex> Agent.stop(pid) :ok iex> flush() {:DOWN, #Reference<0.0.0.551>, :process, #PID<0.66.0>, :normal}