Процесс

@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 - (логическое значение) когда 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(), 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 доставляется немедленно.

См. "The need for monitoring" для примера. См. :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 — абсолютное значение эрланговского монотонного времени, в котором msg должно быть доставлено dest. Чтобы узнать больше об эрланговском монотонном времени и других связанных с временем концепциях, см. документацию модуля System. По умолчанию false.

Примеры

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

@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