@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. Чтобы проверить, является ли процесс на любом узле активным, вы можете использовать модуль :erpc.

:erpc.call(node(pid), Process, :alive?, [pid])

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

@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 - (логическое значение) если false, запрос на отмену является синхронным. Если true, запрос на отмену является асинхронным, что означает, что запрос на отмену таймера отправляется, а :ok возвращается сразу. По умолчанию false.

• :info - (логическое значение) возвращать ли информацию об отмене таймера. Если параметр :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

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

send(pid, {:ping, ref_and_alias})

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 - (логическое значение) когда 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, текущий процесс будет спать бесконечно и не будет потреблять или отвечать на сообщения.

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

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

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

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