@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, не найден. Это может произойти, если таймер истек, был отменён или никогда не соответствовал таймеру.

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

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

Параметры

• :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 не ловит сигналы завершения, он завершится с указанным 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(), atom() | [atom()]) :: {atom(), term()} | [{atom(), term()}] | 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, который не активен или завершен. Обратите внимание, что таймеры не будут автоматически отменены, когда dest — атом (так как разрешение атома происходит во время доставки).

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

Параметры

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

Примеры

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

@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