@spec alias() :: alias()

Создаёт псевдоним процесса.

Это то же самое, что вызов alias/1 как alias([:explicit_unalias]). Также см. :erlang.alias/0.

Встраивается компилятором.

Примеры

alias = Process.alias()

@spec alias([alias_opt()]) :: alias()

Создаёт псевдоним процесса.

См. документацию модуля для получения дополнительной информации о псевдонимах. Также см. :erlang.alias/1.

Встраивается компилятором.

Примеры

alias = Process.alias([:reply])

@spec alive?(pid()) :: boolean()

Определяет, жив ли данный процесс на локальном узле.

Если процесс, идентифицированный как pid, жив (то есть он не завершается и ещё не завершился), то эта функция возвращает true. В противном случае возвращает false.

pid должен ссылаться на процесс, работающий на локальном узле, иначе будет выброшено исключение ArgumentError.

Встраивается компилятором.

@spec cancel_timer(reference(), options) :: non_neg_integer() | false | :ok
when options: [async: boolean(), info: boolean()]

Отменяет таймер, возвращённый функцией send_after/3.

Если результат — целое число, оно представляет собой время в миллисекундах, оставшееся до истечения таймера.

Если результат — false, таймер, соответствующий timer_ref, не найден. Это может произойти, если таймер истек, уже был отменён или timer_ref никогда не соответствовал таймеру.

Даже если таймер истек, а сообщение было отправлено, эта функция не указывает, прибыло ли сообщение таймаута в пункт назначения.

Встраивается компилятором.

Параметры

• :async - (boolean) при false, запрос отмены синхронный. При true, запрос отмены асинхронный, то есть запрос на отмену таймера отправляется, а :ok возвращается сразу. По умолчанию false.

• :info - (boolean) возвращать ли информацию об отмене таймера. Если параметр :async равен false и параметр :info равен true, возвращается либо целое число, либо false (как описано выше). Если параметр :async равен false и параметр :info равен false, возвращается :ok. Если параметр :async равен true и параметр :info равен true, в вызывающий метод отправляется сообщение в формате {:cancel_timer, timer_ref, result} (где result — целое число или false как описано выше) при завершении отмены. Если параметр :async равен true и параметр :info равен false, сообщение не отправляется. По умолчанию true.

@spec delete(term()) :: term() | nil

Удаляет указанный key из словаря процесса.

Возвращает значение, которое находилось под key в словаре процесса, или nil , если key не хранилось в словаре процесса.

Примеры

iex> Process.put(:comments, ["comment", "other comment"])
iex> Process.delete(:comments)
["comment", "other comment"]
iex> Process.delete(:comments)
nil

@spec demonitor(reference(), options :: [:flush | :info]) :: boolean()

Отключает мониторинг процесса, идентифицируемого данным reference.

Если monitor_ref является ссылкой, полученной вызывающим процессом с помощью вызова monitor/1, то мониторинг отключается. Если мониторинг уже отключен, ничего не происходит.

Для получения дополнительной информации см. :erlang.demonitor/2.

Встроенная функция компилятором.

Примеры

pid = spawn(fn -> 1 + 2 end)
ref = Process.monitor(pid)
Process.demonitor(ref)
#=> true

@spec exit(pid(), term()) :: true

Отправляет сигнал завершения с заданным reason процессу pid.

Следующее поведение применимо, если reason является любым термином, кроме :normal или :kill:

1. Если процесс pid не обрабатывает сигналы завершения, процесс pid завершится с заданным reason.

2. Если процесс pid обрабатывает сигналы завершения, сигнал завершения преобразуется в сообщение {:EXIT, from, reason} и отправляется в очередь сообщений процесса pid.

Если reason является атомом :normal, процесс pid не завершится (если только pid не является вызывающим процессом, в этом случае он завершится с причиной :normal). Если процесс обрабатывает сигналы завершения, сигнал завершения преобразуется в сообщение {:EXIT, from, :normal} и отправляется в его очередь сообщений.

Если reason является атомом :kill, то есть вызывается Process.exit(pid, :kill), необрабатываемый сигнал завершения отправляется процессу pid, который безусловно завершит работу с причиной :killed.

Встроенная функция компилятором.

Примеры

Process.exit(pid, :kill)
#=> true

@spec flag(:error_handler, module()) :: module()

@spec flag(:max_heap_size, heap_size()) :: heap_size()

@spec flag(:message_queue_data, :off_heap | :on_heap) :: :off_heap | :on_heap

@spec flag(:min_bin_vheap_size, non_neg_integer()) :: non_neg_integer()

@spec flag(:min_heap_size, non_neg_integer()) :: non_neg_integer()

@spec flag(:priority, priority_level()) :: priority_level()

@spec flag(:save_calls, 0..10000) :: 0..10000

@spec flag(:sensitive, boolean()) :: boolean()

@spec flag(:trap_exit, boolean()) :: boolean()

Устанавливает заданный flag в value для вызывающего процесса.

Возвращает старое значение flag.

Для получения дополнительной информации см. :erlang.process_flag/2.

Встроенная функция компилятором.

@spec flag(pid(), :save_calls, 0..10000) :: 0..10000

Устанавливает заданный flag в value для заданного процесса pid.

Возвращает старое значение flag.

Вызывает исключение ArgumentError, если pid не является локальным процессом.

Допустимые значения для flag представляют собой только подмножество значений, разрешённых в flag/2, а именно :save_calls.

Для получения дополнительной информации см. :erlang.process_flag/3.

Встроенная функция компилятором.

@spec get() :: [{term(), term()}]

Возвращает все пары ключ-значение в словаре процесса.

Встроенная функция компилятором.

@spec get(term(), default :: term()) :: term()

Возвращает значение для данного key в словаре процесса или default , если key не задано.

Примеры

# Assuming :locale was not set
iex> Process.get(:locale, "pt")
"pt"
iex> Process.put(:locale, "fr")
nil
iex> Process.get(:locale, "pt")
"fr"

@spec get_keys() :: [term()]

Возвращает все ключи в словаре процесса.

Встроено компилятором.

Примеры

# Assuming :locale was not set
iex> :locale in Process.get_keys()
false
iex> Process.put(:locale, "pt")
nil
iex> :locale in Process.get_keys()
true

@spec get_keys(term()) :: [term()]

Возвращает все ключи в словаре процесса, которые имеют заданное value.

Встроено компилятором.

@spec group_leader() :: pid()

Возвращает PID лидера группы для вызывающего процесса.

Встроено компилятором.

Примеры

Process.group_leader()
#=> #PID<0.53.0>

@spec group_leader(pid(), leader :: pid()) :: true

Устанавливает лидера группы для данного pid в leader.

Обычно используется, когда процесс, запущенный из определенной оболочки, должен иметь лидера группы, отличного от :init.

Встроено компилятором.

@spec hibernate(module(), atom(), list()) :: no_return()

Переводит вызывающий процесс в состояние "гибернации".

Вызывающий процесс переводится в состояние ожидания, где выделение памяти было уменьшено по возможности. Это полезно, если процесс не ожидает получения сообщений в ближайшем будущем.

См. :erlang.hibernate/3 для получения дополнительной информации.

Встроено компилятором.

@spec info(pid()) :: keyword() | nil

Возвращает информацию о процессе, идентифицированном pid, или возвращает nil если процесс не активен.

Используйте только для отладочной информации.

См. :erlang.process_info/1 для получения дополнительной информации.

@spec info(pid(), process_info_item()) :: process_info_result_item() | nil

@spec info(pid(), [process_info_item()]) :: [process_info_result_item()] | nil

Возвращает информацию о процессе, идентифицированном pid, или возвращает nil если процесс не активен.

См. :erlang.process_info/2 для получения дополнительной информации.

@spec link(pid() | port()) :: true

Создаёт связь между вызывающим процессом и заданным элементом (процессом или портом).

Связи двусторонние. Связанные процессы могут быть разъединены, используя unlink/1.

Если такая связь уже существует, эта функция ничего не делает, так как между двумя заданными процессами может быть только одна связь. Если процесс пытается установить связь с самим собой, ничего не произойдёт.

Когда два процесса связаны, каждый из них получает сигналы выхода от другого (см. также exit/2). Предположим, что pid1 и pid2 связаны. Если pid2 завершается по причине, отличной от :normal (это также причина завершения, используемая, когда процесс завершает свою работу), и pid1 не ловит выходы (см. flag/2), то pid1 завершится с той же причиной, что и pid2, и, в свою очередь, отправит сигнал выхода всем своим другим связанным процессам. Поведение, когда pid1 ловит выходы, описано в exit/2.

См. :erlang.link/1 для получения дополнительной информации.

Встроено компилятором.

@spec list() :: [pid()]

Возвращает список идентификаторов процессов (PID), соответствующих всем процессам, которые в данный момент существуют на локальном узле.

Обратите внимание, что если процесс завершается, он считается существующим, но не активным. Это означает, что для такого процесса alive?/1 вернёт false, но его PID будет частью списка PID, возвращаемого этой функцией.

Для получения дополнительной информации см. :erlang.processes/0.

Встроенная компилятором.

Примеры

Process.list()
#=> [#PID<0.0.0>, #PID<0.1.0>, #PID<0.2.0>, #PID<0.3.0>, ...]

@spec monitor(pid() | {name, node()} | name) :: reference() when name: atom()

Начинает отслеживание указанного item из вызывающего процесса.

После завершения отслеживаемого процесса мониторингу процесса передается сообщение следующего вида:

{:DOWN, ref, :process, object, reason}

где:

• ref — ссылка на монитор, возвращённая этой функцией;
• object — либо pid отслеживаемого процесса (если отслеживается PID), либо {name, node} (если отслеживается удалённое или локальное имя);
• reason — причина выхода из строя.

Если процесс уже завершен при вызове Process.monitor/1, сразу же передается сообщение :DOWN.

См. "Необходимость мониторинга" для примера. См. :erlang.monitor/2 для получения дополнительной информации.

Встроенная компилятором.

Примеры

pid = spawn(fn -> 1 + 2 end)
#=> #PID<0.118.0>
Process.monitor(pid)
#=> #Reference<0.906660723.3006791681.40191>
Process.exit(pid, :kill)
#=> true
receive do
  msg -> msg
end
#=> {:DOWN, #Reference<0.906660723.3006791681.40191>, :process, #PID<0.118.0>, :noproc}

@spec monitor(pid() | {name, node()} | name, [:erlang.monitor_option()]) ::
  reference()
when name: atom()

Начинает отслеживание указанного item из вызывающего процесса.

Эта функция похожа на monitor/1, но принимает параметры для настройки мониторинга item. См. :erlang.monitor/3 для документации по этим параметрам.

Встроенная компилятором.

Примеры

pid =
  spawn(fn ->
    receive do
      {:ping, source_alias} -> send(source_alias, :pong)
    end
  end)
#=> #PID<0.118.0>

ref_and_alias = Process.monitor(pid, alias: :reply_demonitor)
#=> #Reference<0.906660723.3006791681.40191>

send(pid, {:ping, ref_and_alias})

receive do: msg -> msg
#=> :pong

receive do: msg -> msg
#=> {:DOWN, #Reference<0.906660723.3006791681.40191>, :process, #PID<0.118.0>, :noproc}

@spec put(term(), term()) :: term() | nil

Сохраняет заданную пару key-value в словаре процесса.

Возвращаемое значение этой функции — значение, которое ранее хранилось по ключу key, или nil, если значение по этому ключу не хранилось.

Примеры

# Assuming :locale was not set
iex> Process.put(:locale, "en")
nil
iex> Process.put(:locale, "fr")
"en"

@spec read_timer(reference()) :: non_neg_integer() | false

Считывает таймер, созданный с помощью send_after/3.

Если результат — целое число, оно представляет время в миллисекундах, оставшееся до истечения таймера.

Если результат — false, таймер, соответствующий timer_ref, не найден. Это может произойти, если таймер истек, был отменён или timer_ref никогда не соответствовал таймеру.

Даже если таймер истек, а сообщение было отправлено, эта функция не говорит вам, прибыло ли сообщение о тайм-ауте в пункт назначения.

Встроенная компилятором.

@spec register(pid() | port(), atom()) :: true

Регистрирует заданный pid_or_port под заданным name на локальном узле.

name должен быть атомом и может затем использоваться вместо идентификатора PID/порта при отправке сообщений с помощью Kernel.send/2.

register/2 завершится ошибкой ArgumentError в любом из следующих случаев:

• PID/порт не существует локально и не активен
• имя уже зарегистрировано
• pid_or_port уже зарегистрирован под другим name

Следующие имена зарезервированы и не могут быть назначены процессам или портам:

• nil
• false
• true
• :undefined

Примеры

Process.register(self(), :test)
#=> true
send(:test, :hello)
#=> :hello
send(:wrong_name, :hello)
** (ArgumentError) argument error

@spec registered() :: [atom()]

Возвращает список имён, которые были зарегистрированы с помощью register/2.

Встроен в компилятор.

Примеры

Process.register(self(), :test)
Process.registered()
#=> [:test, :elixir_config, :inet_db, ...]

@spec send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend
when dest: dest(), msg: any(), option: :noconnect | :nosuspend

Отправляет сообщение заданному dest.

dest может быть удалённым или локальным PID, локальным портом, локально зарегистрированным именем или кортежем в форме {registered_name, node} для зарегистрированного имени на другом узле.

Встроен в компилятор.

Параметры

• :noconnect - при использовании, если отправка сообщения потребует автоматического подключения к другому узлу, сообщение не отправляется, и возвращается :noconnect.

• :nosuspend - при использовании, если отправка сообщения приведёт к приостановке отправителя, сообщение не отправляется, и возвращается :nosuspend.

В противном случае сообщение отправляется, и возвращается :ok.

Примеры

iex> Process.send({:name, :node_that_does_not_exist}, :hi, [:noconnect])
:noconnect

@spec send_after(pid() | atom(), term(), non_neg_integer(), [option]) :: reference()
when option: {:abs, boolean()}

Отправляет msg в dest через time миллисекунд.

Если dest является PID, это должен быть PID локального процесса, мертвого или живого. Если dest является атомом, это должно быть имя зарегистрированного процесса, которое ищется на момент доставки. Ошибка не генерируется, если имя не ссылается на процесс.

Сообщение не отправляется немедленно. Поэтому dest может получать другие сообщения между ними, даже когда time 0.

Эта функция возвращает ссылку на таймер, который можно прочитать с помощью read_timer/1 или отменить с помощью cancel_timer/1.

Таймер будет автоматически отменён, если заданный dest является PID, который не активен или когда заданный PID завершается. Обратите внимание, что таймеры не будут автоматически отменяться, когда dest является атомом (так как разрешение атома выполняется при доставке).

Встроен в компилятор.

Параметры

• :abs - (boolean) если false, time обрабатывается как относительное к текущему монотонному времени. Если true, time является абсолютным значением Erlang монотонного времени, в которое msg должен быть доставлен dest. Чтобы узнать больше о монотонном времени Erlang и других связанных с временем понятиях, см. документацию для модуля System. По умолчанию false.

Примеры

timer_ref = Process.send_after(pid, :hi, 1000)

@spec set_label(term()) :: :ok

Добавить описательное имя текущему процессу.

Имя не обязательно должно быть уникальным, и в Erlang/OTP 27+ оно будет отображаться в наблюдателе и в логах сбоев. Это имя может быть полезным для идентификации процесса как одного из нескольких в заданной роли, например, :queue_worker или {:live_chat, user_id}.

Примеры

Process.set_label(:worker)
#=> :ok

Process.set_label({:any, "term"})
#=> :ok

@spec sleep(timeout()) :: :ok

Приостанавливает выполнение текущего процесса на заданный timeout.

timeout — это либо количество миллисекунд для сна в виде целого числа, либо атом :infinity. Когда задано :infinity, текущий процесс будет приостановлен навсегда и не будет потреблять или отвечать на сообщения.

Используйте эту функцию с большой осторожностью. Почти во всех ситуациях, где в Elixir вы бы использовали sleep/1, скорее всего, существует более правильный, быстрый и точный способ достижения того же с помощью передачи сообщений.

Например, если вы ожидаете, что процесс выполнит какое-либо действие, лучше передавать сообщения о прогрессе такого действия.

Другими словами, не делайте:

Task.start_link(fn ->
  do_something()
  ...
end)

# Wait until work is done
Process.sleep(2000)

Но делайте:

parent = self()

Task.start_link(fn ->
  do_something()
  send(parent, :work_is_done)
  ...
end)

receive do
  :work_is_done -> :ok
after
  # Optional timeout
  30_000 -> :timeout
end

В случаях, подобных описанному выше, Task.async/1 и Task.await/2 предпочтительнее.

Аналогично, если вы ожидаете завершения процесса, отслеживайте этот процесс вместо того, чтобы приостанавливать его. Не делайте:

Task.start_link(fn ->
  ...
end)

# Wait until task terminates
Process.sleep(2000)

Вместо этого делайте:

{:ok, pid} =
  Task.start_link(fn ->
    ...
  end)

ref = Process.monitor(pid)

receive do
  {:DOWN, ^ref, _, _, _} -> :task_is_down
after
  # Optional timeout
  30_000 -> :timeout
end

@spec spawn((-> any()), spawn_opts()) :: pid() | {pid(), reference()}

Запускает заданную функцию в соответствии с заданными параметрами.

Результат зависит от заданных параметров. В частности, если :monitor задан как параметр, он вернёт кортеж, содержащий PID и ссылку на мониторинг, в противном случае только PID запущенного процесса.

Доступно больше параметров; для полного списка доступных параметров см. :erlang.spawn_opt/4.

Встраивается компилятором.

Примеры

Process.spawn(fn -> 1 + 2 end, [:monitor])
#=> {#PID<0.93.0>, #Reference<0.18808174.1939079169.202418>}
Process.spawn(fn -> 1 + 2 end, [:link])
#=> #PID<0.95.0>

@spec spawn(module(), atom(), list(), spawn_opts()) :: pid() | {pid(), reference()}

Запускает заданную функцию fun из модуля mod, передавая заданные args в соответствии с заданными параметрами.

Результат зависит от заданных параметров. В частности, если :monitor задан как параметр, он вернёт кортеж, содержащий PID и ссылку на мониторинг, в противном случае только PID запущенного процесса.

Также принимает дополнительные параметры; для списка доступных параметров см. :erlang.spawn_opt/4.

Встраивается компилятором.

@spec unalias(alias()) :: boolean()

Явно деактивирует псевдоним процесса.

Возвращает true, если alias был текущим активным псевдонимом для текущих процессов, или false в противном случае.

См. документацию модуля для получения дополнительной информации о псевдонимах. Также см. :erlang.unalias/1.

Встраивается компилятором.

Примеры

alias = Process.alias()
Process.unalias(alias)
#=> true

@spec unlink(pid() | port()) :: true

Удаляет связь между вызывающим процессом и заданным элементом (процесс или порт).

Если такой связи нет, эта функция ничего не делает. Если pid_or_port не существует, эта функция не генерирует ошибок и просто ничего не делает.

Значение возвращаемое этой функцией всегда true.

См. :erlang.unlink/1 для получения дополнительной информации.

Встроено компилятором.

@spec unregister(atom()) :: true

Удаляет зарегистрированный name, связанный с идентификатором PID или порта.

Возвращает ошибку ArgumentError, если имя не зарегистрировано ни для какого PID или порта.

Встроено компилятором.

Примеры

Process.register(self(), :test)
#=> true
Process.unregister(:test)
#=> true
Process.unregister(:wrong_name)
** (ArgumentError) argument error

@spec whereis(atom()) :: pid() | port() | nil

Возвращает идентификатор PID или порта, зарегистрированный под name или nil , если имя не зарегистрировано.

См. :erlang.whereis/1 для получения дополнительной информации.

Примеры

Process.register(self(), :test)
Process.whereis(:test)
#=> #PID<0.84.0>
Process.whereis(:wrong_name)
#=> nil