erlang

模块

erlang

模块摘要

Erlang BIF。

描述

按照惯例，大多数内置函数（BIF）都包含在此模块中。一些BIF或多或少地被视为Erlang编程语言的一部分，并被自动导入。因此，没有必要指定模块名称。例如，调用atom_to_list(Erlang)和erlang:atom_to_list(Erlang)相同。

自动导入的BIF没有模块前缀。列出带有模块前缀的BIF不是自动导入的。

BIF可能由于各种原因而失败。 如果使用不正确类型的参数调用它们，所有BIF都会因为badarg而失败。 其他原因在每个BIF的描述中都有描述。

一些BIF可以用于防护测试，并标记为“允许进行防护测试”。

数据类型

ext_binary()

一种二进制数据对象，按照Erlang外部术语格式构造。

iovec()

二进制文件列表。这个数据类型可以和enif_inspect_iovec一起使用。

message_queue_data() = off_heap | on_heap

见process_flag(message_queue_data, MQD)...

timestamp() =

{MegaSecs :: integer() >= 0,

Secs :: integer() >= 0,

MicroSecs :: integer() >= 0}

见erlang:timestamp/0...

time_unit() =

integer() >= 1 |

second |

millisecond |

microsecond |

nanosecond |

native |

perf_counter |

deprecated_time_unit()

支持的时间单位表示：

PartsPerSecond :: integer() >= 1

时间单位以秒/秒表示。也就是说，时间单位等于1/PartsPerSecond秒。

second

由整数表示的时间单位的符号表示1。

millisecond

由整数表示的时间单位的符号表示1000。

microsecond

由整数表示的时间单位的符号表示1000000。

nanosecond

由整数表示的时间单位的符号表示1000000000。

native

Erlang运行时系统使用的本地时间单位的符号表示。

native时间单位是在运行时系统开始确定，并且直到运行时系统终止保持相同。如果运行系统停止后再重新启动（即使在同一台机器上），native则新运行时系统实例的native时间单位可能与旧运行时系统实例的时间单位不同。

native通过调用来获得时间单位的近似值erlang:convert_time_unit(1, second, native)。结果等于native每秒全部时间单位的数量。如果native每秒的时间单位数不等于整数，则结果向下舍入。

注

native时间单位的值可以让您或多或少地了解有关时间质量值的信息。它为时间值resolution和precision时间值设置了一个限制，但它没有提供关于accuracy时间值的信息。所述分辨率native时间单元和时间值的分辨率可以显著不同。

perf_counter

Erlang运行时系统使用的性能计数器时间单位的符号表示。

该perf_counter时间单位的行为以同样的方式为多native时间单位。也就是说，它可以在运行时间重启之间有所不同。要获得这种类型的值，请调用os:perf_counter/0。

deprecated_time_unit()

为了向后兼容而保留的不推荐的符号表示。

time_unit/0类型可被扩展。要在时间单位之间转换时间值，请使用erlang:convert_time_unit/3。

deprecated_time_unit() =

seconds | milli_seconds | micro_seconds | nano_seconds

该time_unit()类型还包含以下不建议使用的符号时间单位：

seconds

同second...

milli_seconds

同millisecond...

micro_seconds

同microsecond...

nano_seconds

同nanosecond...

输出

abs(Float) -> float()

abs(Int) -> integer() >= 0

类型

类型

返回整数或浮点数，该整数或浮点数是Float或Int，例如：

> abs(-3.33).
3.33
> abs(-3).
3

允许在 when 模式匹配下使用

erlang:adler32(Data) -> integer() >= 0

类型

计算并返回adler32校验和Data。

erlang:adler32(OldAdler, Data) -> integer() >= 0

类型

通过将前面的校验和OldAdler与校验和相结合，继续计算adler32校验和Data。

以下代码：

X = erlang:adler32(Data1),
Y = erlang:adler32(X,Data2).

分配相同的值给Y如下：

Y = erlang:adler32([Data1,Data2]).

erlang:adler32_combine(FirstAdler, SecondAdler, SecondSize) ->

integer() >= 0

类型

结合两个先前计算的adler32校验和。该计算需要知道第二次校验和的数据对象的大小。

以下代码：

Y = erlang:adler32(Data1),
Z = erlang:adler32(Y,Data2).

分配相同的值给Z如下：

X = erlang:adler32(Data1),
Y = erlang:adler32(Data2),
Z = erlang:adler32_combine(X,Y,iolist_size(Data2)).

erlang:append_element(Tuple1, Term) -> Tuple2

类型

返回一个元素多于一个的新元组Tuple1，并且包含Tuple1后面的元素Term作为最后一个元素。在语义上相当于list_to_tuple(tuple_to_list(Tuple1) ++ [Term])，但更快。例：

> erlang:append_element({one, two}, three).
{one,two,three}

apply(Fun, Args) -> term()

类型

调用一个函数，将元素Args作为参数传递。

如果参数中元素的数量在编译时已知，则调用最好写为Fun(Arg1, Arg2, ... ArgN)。

警告

此前，Fun也可以指定为{Module, Function}，相当于apply(Module, Function, Args)。此用法已弃用，并将在未来版本中停止工作。

apply(Module, Function, Args) -> term()

类型

返回将结果Function在Module到Args。应用函数必须从中导出Module。函数的长度是长度Args。例：

> apply(lists, reverse, [[a, b, c]]).
[c,b,a]
> apply(erlang, atom_to_list, ['Erlang']).
"Erlang"

如果参数个数在编译时已知，则调用更好写为Module:Function(Arg1, Arg2, ..., ArgN)。

如果未导出应用函数，则会调用error_handler：undefined_function / 3。 错误处理程序可以重新定义（请参阅process_flag / 2）。 如果error_handler未定义，或者用户重新定义了默认的error_handler，所以替换模块未定义，则会生成一个带有undef原因的错误。

atom_to_binary(Atom, Encoding) -> binary()

类型

返回对应于文本表示的二进制文件Atom。如果Encoding是latin1，则文本表示中的每个字符都存在一个字节。如果Encoding是utf8或unicode，则字符使用UTF-8编码，其中字符可能需要多个字节。

注

从Erlang / OTP 20开始，原子可以包含任何Unicode字符，atom_to_binary(Atom, latin1)如果文本表示Atom包含Unicode字符> 255 ，则原子可能会失败。

例子：

> atom_to_binary('Erlang', latin1).
<<"Erlang">>

atom_to_list(Atom) -> string()

类型

返回对应于文本表示的字符串Atom，例如：

> atom_to_list('Erlang').
"Erlang"

binary_part(Subject, PosLen) -> binary(

类型

提取由PosLen描述的二进制文件的一部分

可以使用负长度来提取二进制文件末尾的字节，例如：

1> Bin = <<1,2,3,4,5,6,7,8,9,10>>.
2> binary_part(Bin,{byte_size(Bin), -5}).
<<6,7,8,9,10>>

失败：badarg 如果PosLen以任何方式在二进制外引用。

Start是基于零的，即：

1> Bin = <<1,2,3>>
2> binary_part(Bin,{0,2}).
<<1,2>>

有关PosLen语义的详细信息，请参阅binary(3)。

允许在 when 模式匹配下使用

binary_part(Subject, Start, Length) -> binary()

类型

和binary_part(Subject, {Start, Length})一样。

允许在 when 模式匹配下使用

binary_to_atom(Binary, Encoding) -> atom()

类型

返回其文本表示形式为二进制的原子。 如果编码是latin1，则二进制中的字节不会转换。 如果编码为utf8或unicode，则二进制文件必须包含有效的UTF-8序列。

注

从Erlang / OTP 20开始，binary_to_atom（Binary，utf8）能够编码任何Unicode字符。 如果二进制文件包含的Unicode字符> 255，则以前的版本会失败。有关原子中的Unicode支持的详细信息，请参阅用户指南的“外部术语格式”一节中有关UTF-8编码原子的注释。

例子：

> binary_to_atom(<<"Erlang">>, latin1).
'Erlang'
> binary_to_atom(<<1024/utf8>>, utf8).
'Ѐ'

binary_to_existing_atom(Binary, Encoding) -> atom()

类型

类似于binary_to_atom/2，但原子必须存在。

失败：如果原子不存在，则为badarg

注

请注意，编译器可能会优化掉原子。例如，编译器将重写atom_to_list(some_atom)为"some_atom"。如果该表达式是some_atom包含模块中唯一提及的原子，则在模块加载时不会创建原子，并且随后的调用binary_to_existing_atom(<<"some_atom">>, utf8)将失败。

binary_to_float(Binary) -> float()

类型

返回文本表示为Binary，例如：

> binary_to_float(<<"2.2017764e+0">>).
2.2017764

失败：如果Binary包含浮点的错误表示则为badarg

binary_to_integer(Binary) -> integer()

类型

返回文本表示为Binary，例如：

> binary_to_integer(<<"123">>).
123

失败：如果Binary包含整数的错误表示形式则为badarg

binary_to_integer(Binary, Base) -> integer()

类型

返回其基数Base为文本表示的整数Binary，例如：

> binary_to_integer(<<"3FF">>, 16).
1023

失败：如果Binary包含整数的错误表示形式则为badarg

binary_to_list(Binary) -> byte()

类型

返回对应于字节的整数列表Binary。

binary_to_list(Binary, Start, Stop) -> byte()

类型

1..byte_size(Binary)

如binary_to_list/1，但返回对应于从字节位置整数列表Start到位置Stop在Binary。二进制中的位置从1开始编号。

注

该函数使用的二进制文件的基于一的索引已被弃用。新的代码是binary:bin_to_list/3在STDLIB中使用。模块中的所有功能binary始终使用从零开始的索引。

binary_to_term(Binary) -> term()

类型

返回解码二进制对象的Erlang项，该对象Binary必须按照Erlang external term format。

> Bin = term_to_binary(hello).
<<131,100,0,5,104,101,108,108,111>>
> hello = binary_to_term(Bin).
hello

警告

解码来自不受信任来源的二进制文件时，请考虑使用binary_to_term/2以防止拒绝服务攻击。

另见term_to_binary/1和binary_to_term/2

binary_to_term(Binary, Opts) -> term()

类型

作为binary_to_term/1，但需要影响二进制解码的选项。

备选方案：

safe

从不受信任的源接收二进制文件时使用此选项。

当启用时，它防止解码数据可以用来攻击Erlang系统。如果接收到不安全的数据，则使用badarg错误。

这可以防止直接创建新原子，间接创建新原子（因为它们嵌入某些结构中，例如进程标识符，引用和乐句），并创建新的外部函数引用。这些资源中没有一个是垃圾收集的，因此对其进行未经检查的创建可能会耗尽可用内存。

失败：如果safe指定不安全数据则为badarg

> binary_to_term(<<131,100,0,5,104,101,108,108,111>>, [safe]).
** exception error: bad argument
> hello.
hello
> binary_to_term(<<131,100,0,5,104,101,108,108,111>>, [safe]).
hello

另见term_to_binary/1，binary_to_term/1，和list_to_existing_atom/1

bit_size(Bitstring) -> integer() >= 0

类型

返回一个整数，该整数的大小以Bitstring，例如：

> bit_size(<<433:16,3:3>>).
19
> bit_size(<<1,2,3>>).
24

允许在when模式匹配下使用

bitstring_to_list(Bitstring) -> byte() | bitstring()

类型

返回对应于字节的整数列表Bitstring。如果二进制中的位数不能被8整除，则列表的最后一个元素是包含剩余1-7位的位串。

erlang:bump_reductions(Reductions) -> true

类型

该实现相关函数增加调用进程的减少计数器。在波束仿真器中，对于每个功能和BIF呼叫，减法计数器通常会递增1。当计数器达到一个进程的最大减少数时（Erlang / OTP R12B减少2000个），强制上下文切换。

警告

此BIF可以在未来版本的光束机中删除，无需事先警告。它不太可能在其他Erlang实现中实现。

byte_size(Bitstring) -> integer() >= 0

类型

返回一个整数，它是需要包含的字节数Bitstring。也就是说，如果在比特数Bitstring不是由8整除，所得到的字节数被舍入最多。例子：

> byte_size(<<433:16,3:3>>).
3
> byte_size(<<1,2,3>>).
3

允许在when模式匹配下使用

erlang:cancel_timer(TimerRef) -> Result

类型

取消计时器。跟调用erlang:cancel_timer(TimerRef, [])一样。

erlang:cancel_timer(TimerRef, Options) -> Result | ok

类型

取消由erlang：start_timer或erlang：send_after创建的计时器。 TimerRef标识定时器，并由创建定时器的BIF返回。

Options：

{async, Async}

异步请求取消。 异步默认为false，这会导致取消同步执行。 当Async设置为true时，取消操作异步执行。 也就是说，cancel_timer（）向管理定时器的定时器服务发送取消异步请求，然后返回ok。

{info, Info}

请求有关Result取消的信息。Info默认为true，这意味着Result给出。如果Info设置为false，则不会提供有关取消结果的信息。

• Async为false时：如果Info为true，则结果由erlang：cancel_timer（）返回。 否则返回。

• Async为true时：如果Info为true，则在执行取消操作时，将形式为{cancel_timer，TimerRef，Result}的消息发送给erlang：cancel_timer（）的调用方，否则不会发送消息。

Option未来可能会增加更多的功能。

如果Result是整数，则表示以毫秒为单位的时间，直到取消的计时器过期。

如果Result是false，则TimerRef找不到对应的计时器。这可能是因为计时器已过期，已经被取消，或者因为TimerRef从未与计时器相对应。即使计时器已过期，它也不会告诉您超时消息是否已到达目的地。

注

管理定时器的定时器服务可以与调用进程正在执行的调度器之外的另一个调度器共处一处。如果是这样，与定时器服务的通信比在本地定位服务需要更长的时间。如果调用进程处于关键路径中，并且在等待此操作的结果时可以执行其他操作，或者对操作结果不感兴趣，则需要使用选项{async, true}。如果使用选项{async, false}，调用进程会阻塞，直到执行完操作。

另见erlang:send_after/4，erlang:start_timer/4，和erlang:read_timer/2

ceil(Number) -> integer()

类型

返回不小于的最小整数Number。例如：

> ceil(5.5).
6

允许在when模式匹配下使用

check_old_code(Module) -> boolean()

类型

如果Module有旧代码，则返回true，否则返回false。

另见code(3)...

check_process_code(Pid, Module) -> CheckResult

类型

同check_process_code(Pid,Module, [])...

check_process_code(Pid, Module, OptionList) -> CheckResult | async

类型

检查节点本地进程是否由Pid执行旧代码Module...

Options：

{allow_gc, boolean()}

确定执行操作时是否允许垃圾回收。 如果{allow_gc，false}被传递，并且需要一个垃圾收集来确定操作的结果，则该操作被中止（参见下面的CheckResult的信息）。 默认情况下允许垃圾回收，即{allow_gc，true}。

{async, RequestId}

函数check_process_code / 3在发送请求后立即返回异步值。 处理请求时，调用此函数的进程将以{check_process_code，RequestId，CheckResult}形式传递消息。

如果Pid等于self()，且没有async选项通过，则立即执行操作。否则，操作请求会发送到由标识的进程Pid，并在适当时处理。如果没有async选项通过，呼叫者阻止直到CheckResult可用并且可以返回。

CheckResult请求的结果如下：

true

所确定的过程Pid执行旧代码Module也就是说，进程的当前调用为该模块执行旧代码，或者该进程对此模块的旧代码具有引用，或者该进程包含引用该模块旧代码的函数。

false

标识的过程Pid不会执行旧代码Module。

aborted

该操作被中止，因为需要对进程进行垃圾回收以确定操作结果，并且通过传递选项请求操作{allow_gc, false}。

注

直到ERTS版本8. *，检查进程代码操作检查对旧代码的所有类型的引用。也就是说，直接引用（例如进程堆栈上的返回地址），间接引用（fun在进程上下文中）以及代码中文字的引用。

从ERTS 9.0版开始，检查过程代码操作仅检查对代码的直接引用。通过funs的间接引用将被忽略。如果fun存在并且在清除旧代码之后使用，则会在使用时引发异常（与fun清除后进程接收到的情况相同）。文字将在后期被照顾（复制）。此行为可以在启用ERTS版本8.1时启用building OTP，并且在启用脏调度程序支持时自动启用。

另见code(3)...

失败：

badarg 如果Pid不是节点本地进程标识符。

badarg 如果Module不是原子。

badarg 如果OptionList是一个无效的选项列表。

erlang:convert_time_unit(Time, FromUnit, ToUnit) -> ConvertedTime

类型

转换Time时间单位值FromUnit相应的ConvertedTime时间单位值ToUnit.结果使用floor函数四舍五入。

警告

在时间单位之间转换时，您可能会失去准确性和精度。为了尽量减少此类损失，请在native时间单元收集所有数据，并对最终结果进行转换。

erlang:crc32(Data) -> integer() >= 0

类型

计算并返回crc32（IEEE 802.3样式）校验和Data。

erlang:crc32(OldCrc, Data) -> integer() >= 0

类型

通过将前面的校验和OldCrc与校验和相结合，继续计算crc32校验和Data。

以下代码：

X = erlang:crc32(Data1),
Y = erlang:crc32(X,Data2).

分配相同的值给Y如下：

Y = erlang:crc32([Data1,Data2]).

erlang:crc32_combine(FirstCrc, SecondCrc, SecondSize) ->

integer() >= 0

类型

合并两个先前计算的crc 32校验和。这种计算需要已知第二校验和的数据对象的大小。

以下代码：

Y = erlang:crc32(Data1),
Z = erlang:crc32(Y,Data2).

分配相同的值给Z如下：

X = erlang:crc32(Data1),
Y = erlang:crc32(Data2),
Z = erlang:crc32_combine(X,Y,iolist_size(Data2)).

date() -> Date

类型

返回当前日期为{Year, Month, Day}...

时区和夏令时校正取决于底层操作系统。例子：

> date().
{1995,2,19}

erlang:decode_packet(Type, Bin, Options) ->

{OK，Packet，REST}

{更多，长度}

{错误，原因]

类型

Bin根据指定的数据包协议解码二进制文件Type。与带有选项的套接字完成的数据包处理类似{packet,Type}.

如果整个数据包都包含在Bin中，它将与剩余的二进制一起返回为{ok，Packet，Rest}。

如果Bin不包含整个数据包，则返回{more，Length}。 长度是数据包的预期总大小，如果预期数据包大小未知，则长度不确定。 然后可以再次调用decode_packet并添加更多数据。

如果数据包不符合协议格式，{error,Reason}则被返回。

Types：

raw | 0

不进行数据包处理。返回整个二进制文件，除非它是空的。

1 | 2 | 4

数据包包含一个标题，指定数据包中的字节数，然后是该字节数。头部的长度可以是一个，两个或四个字节; 字节的顺序是big-endian。数据包返回时，标题被剥离。

line

数据包是由分隔符字节终止的行，默认为拉丁文-1换行符。分隔符字节包含在返回的数据包中，除非该行根据选项被line_length截断。

asn1 | cdr | sunrm | fcgi | tpkt

标题没有被删除。

数据包类型的含义如下所示：

asn1 - ASN.1 BER - Sun的RPC编码- CORBA（GIOP 1.1）- 快速CGI - TPKT格式RFC1006sunrm cdr fcgi tpkt http | httph | http_bin | httph_bin

超文本传输​​协议。数据包以HttpPacket前面描述的格式返回。数据包是请求，响应，标题或标题标记的结尾。无效的行被返回为HttpError。

已识别的请求方法和标题字段以原子形式返回。其他人以字符串形式返回。例如，首先用大写字母和连字符后面的字符串格式化无法识别的标题字段"Sec-Websocket-Key"。

协议类型http只在预期HttpRequest或HttpResponse时用于第一行。 以下调用将使用httph来获取HttpHeaders，直到返回http_eoh，这标志了标题的结尾和任何后续消息主体的开始。

变体http_bin和httph_bin返回字符串（HttpString）作为二进制文件而不是列表。

备选方案：

{packet_size, integer() >= 0}

设置数据包主体的最大允许大小。如果数据包标题指示数据包的长度大于最大允许长度，则该数据包被认为是无效的。默认为0，这意味着没有大小限制。

{line_length, integer() >= 0}

对于数据包类型line，比指定长度更长的行被截断。

如果本身没有设置，选项line_length也适用于http*数据包类型作为选项的别名。此用途仅用于向后兼容。packet_sizepacket_size

{line_delimiter, 0 =< byte() =< 255}

对于数据包类型line，设置分隔字节。默认值是拉丁文-1字符$\n。

例子：

> erlang:decode_packet(1,<<3,"abcd">>,[]).
{ok,<<"abc">>,<<"d">>}
> erlang:decode_packet(1,<<5,"abcd">>,[]).
{more,6}

erlang:delete_element(Index, Tuple1) -> Tuple2

类型

1..tuple_size(Tuple1)

返回带有元素的新元组Index从元组移除Tuple1，例如：

> erlang:delete_element(2, {one, two, three}).
{one,three}

delete_module(Module) -> true | undefined

类型

使当前代码Module成为旧代码并从导出表中删除此模块的所有引用。如果模块不存在则返回undefined，否则返回true。

警告

这个BIF用于代码服务器（见code(3)），不用于其他地方。

失败：badarg如果已经有一个旧版本的Module...

demonitor(MonitorRef) -> true

类型

如果MonitorRef是通过调用获得调用进程的引用，monitor/2则关闭此监视。如果监控已关闭，则不会发生任何事情。

一旦demonitor（MonitorRef）返回，将保证由于监视器而将{{DOWN'，MonitorRef，_，_，_}消息放在将来的呼叫者消息队列中。 但是，在调用之前，可以在呼叫者消息队列中放置{'DOWN'，MonitorRef，_，_，_}消息。 因此，通常建议在监视停止后从消息队列中删除这样的“DOWN”消息。 如果需要清理，可以使用demonitor（MonitorRef，[flush]）而不是demonitor（MonitorRef）。

注

在Erlang / OTP R11B（ERTS 5.5）demonitor/1完全异步运行之前，也就是说，监视器一直处于活动状态，直到“监视器信号”到达被监视实体。这有一个不良影响。你永远无法知道你何时保证不会DOWN因为显示器而收到消息。

当前行为可以看作是两个组合操作：异步发送一个“监视器信号”给被监视的实体，并忽略监视器的未来结果。

失败：如果MonitorRef引用由另一个进程启动的监视，则是错误的。并非所有这些案例都很便宜。如果检查很便宜，则调用失败badarg，例如，如果MonitorRef是远程引用。

demonitor(MonitorRef, OptionList) -> boolean()

类型

返回的值是true，除非信息是OptionList的一部分。

demonitor(MonitorRef, [])等于demonitor(MonitorRef)...

Options：

flush

{_, MonitorRef, _, _, _}在监视停止后，从调用者消息队列中删除（一个）消息（如果有）。

调用demonitor(MonitorRef, [flush])等同于以下内容，但效率更高：

demonitor(MonitorRef),
receive
    {_, MonitorRef, _, _, _} ->
        true
after 0 ->
        true
end

info

返回的值如下：

true

监视器被找到并移除。在这种情况下，不是'DOWN'与此监视器对应的消息已经传递，并且将不会传递。

false

没有找到监视器，也无法移除监视器。这可能是因为有人已经把'DOWN'与调用方消息队列中的此监视器对应的消息。

如果选项info与选项flush相结合，false则在需要刷新时返回，否则返回true。

注

在未来的版本中可以添加更多的选项。

失败：

badarg如果OptionList不是一个列表。 badarg如果Option是无效选项。 badarg与之相同的失败demonitor/1。

disconnect_node(Node) -> boolean() | ignored

类型

强制断开节点。这对节点来说Node就好像本地节点已经崩溃一样。这个BIF主要用于Erlang网络认证协议。

如果断开连接成功则返回true，否则返回false。 如果本地节点不活动，则返回忽略。

erlang:display(Term) -> true

类型

Term在标准输出上打印文本表示。

警告

此BIF仅用于调试。

element(N, Tuple) -> term()

类型

1..tuple_size(Tuple)

返回第Nn个元素（从1开始编号）Tuple，例如：

> element(2, {a, b, c}).
b

允许在when模式匹配下使用

erase() -> {Key, Val}

类型

返回进程字典并删除它，例如：

> put(key1, {1, 2, 3}),
put(key2, [a, b, c]),
erase().
[{key1,{1,2,3}},{key2,[a,b,c]}]

erase(Key) -> Val | undefined

类型

返回Val与Key流程字典关联的值并将其从流程字典中删除。undefined如果没有值关联，则返回Key。例：

> put(key1, {merry, lambs, are, playing}),
X = erase(key1),
{X, erase(key1)}.
{{merry,lambs,are,playing},undefined}

error(Reason) -> no_return()

类型

以原因停止调用进程的执行，任何术语Reason在哪里Reason。退出的原因是{Reason, Where}，Where最近调用的函数列表（当前函数首先）。由于评估此函数会导致进程终止，因此它没有返回值。例：

> catch error(foobar).
{'EXIT',{foobar,[{erl_eval,do_apply,5},
                 {erl_eval,expr,5},
                 {shell,exprs,6},
                 {shell,eval_exprs,6},
                 {shell,eval_loop,3}]}}

error(Reason, Args) -> no_return()

类型

停止执行调用进程的原因Reason，其中Reason是任何术语。 退出原因是{Reason，Where}，其中Where是最近调用的函数列表（当前函数首先）。 预期参数是当前函数的参数列表; 在Beam中，它用于为术语Where中的当前函数提供参数。 由于评估此函数会导致进程终止，因此它没有返回值。

exit(Reason) -> no_return()

类型

以退出原因停止调用进程的执行，任何术语Reason存在Reason。由于评估此函数会导致进程终止，因此它没有返回值。例：

> exit(foobar).
** exception exit: foobar
> catch exit(foobar).
{'EXIT',foobar}

exit(Pid, Reason) -> true

类型

将退出原因的退出信号发送Reason到由标识的进程或端口Pid。

以下行为适用于Reason任何术语，除了normal或kill：

• 如果Pid不是困住出口，Pid本身有退出的理由Reason...

• 如果Pid陷阱退出，则退出信号被转换为消息{'EXIT', From, Reason}并传递到消息队列Pid中。

• From是发送退出信号的进程的进程标识符。另请参阅process_flag / 2.如果Reason为原子正常，则Pid不会退出。如果是陷阱退出，退出信号被转换成消息{'EXIT'，From，normal}并传递到它的消息队列中。如果Reason是原子杀死，即如果调用exit（Pid，kill）无法获取的退出信号被发送到Pid，它无条件地退出并退出reason.erlang：external_size（Term） - > integer（）> = 0TypesCalculates在不执行编码的情况下，在Erlang外部术语中编码的项的最大字节大小格式。以下条件始终适用：> Size1 = byte_size（term_to_binary（Term）），

> Size2 = erlang：external_size（Term），

> true = Size1 = <Size2。

这相当于调用：erlang：external_size（Term，[]）erlang：external_size（Term，Options） - > integer（）> = 0TypesCalculates在不进行编码的情况下，在Erlang中编码的术语的最大字节大小外部术语格式。以下条件始终适用：> Size1 = byte_size（term_to_binary（Term，Options）），

> Size2 = erlang：external_size（Term，Options），

> true = Size1 = <Size2。

trueOption {minor_version，Version}指定如何编码浮动。有关详细说明，请参阅term_to_binary / 2.float（Number） - > float（）Types通过将Number转换为浮点数来返回浮点数，例如：> float（55）。

55.0允许在警戒测试中使用。注意如果用在警卫的顶层，它将测试参数是否是浮点数;为清楚起见，可以使用is_float / 1来代替。当float / 1用于守护中的表达式时，例如'float（A）== 4.0'，它将按照前面所述转换一个数。浮点数_二进制（浮点数） - >二进制数）类型与float_to_binary相同（Float，[{scientific，20}]）。float_to_binary（Float，Options） - > binary（）类型使用固定小数点格式化返回与Float的文本表示形式相对应的二进制文件。选项的行为与float_to_list / 2相同。示例：> float_to_binary（7.12，[{decimals，4}]）。

<< “7.1200” >>

> float_to_binary（7.12，[{decimals，4}，compact]）。

<<“7.12”>> float_to_list（Float） - > string（）类型与float_to_list（Float，[{scientific，20}]）相同float_to_list（Float，Options） - > string（）Types返回与文本对应的字符串Float使用固定小数点格式表示。可用选项：

• 如果decimals指定了选项，则返回的值至多包含Decimals小数点后的数字。如果该数字不适合256字节的内部静态缓冲区，则该函数将抛出badarg。

• 如果compact指定了选项，则列表末尾的尾部零将被截断。此选项仅与选项decimals一起有意义。

• 如果scientific指定了选项，则浮点格式将使用带Decimals精度数字的科学记数法进行格式化。

• 如果Options是[]，则该函数的行为如下float_to_list/1。示例：> float_to_list（7.12，[{decimals，4}]）。“7.1200”> float_to_list（7.12，[{decimals，4}，compact]）。“7.12”floor（Number） - > integer（）类型返回不大于的最大整数Number。例如：> floor（-10.5）。-11All guarded tests.erlang：fun_info（Fun） - > {Item，Info} TypesReturns关于乐趣的信息列表Fun。每个列表元素都是一个元组。元组的顺序是未定义的，在将来的版本中可以添加更多的元组.Warning这个BIF主要用于调试，但它有时可用于需要验证的库函数，例如有趣的元素。两种类型的乐趣语义略有不同：

• 创造的函数fun M:F/A被称为外部函数。调用它将始终F使用A模块的最新代码中的arity 调用该函数M。注意，创建M函数时，模块甚至不需要加载fun M:F/A。

• 所有其他的乐趣都被称为局部在调用本地乐趣时，即使加载了更新版本的模块，创建乐趣的代码的相同版本也称为%28。列表中始终有以下本地和外部元素：{type, Type}Type是local或external...{module, Module}Module%28 an原子%29是模块名。如果Fun是当地的乐趣，Module是定义乐趣的模块。如果Fun是一种外在的乐趣，Module是乐趣所指的模块。{name, Name}Name%28 a原子%29是函数名。如果Fun是当地的乐趣，Name实现乐趣的本地函数的名称。%28此名称由编译器生成，仅用于信息。由于它是一个本地函数，所以不能直接调用它。%29如果当前没有加载代码，[]而不是原子。如果Fun是一种外在的乐趣，Name所引用的导出函数的名称。{arity, Arity}Arity是调用乐趣的参数数。{env, Env}Env%28a列表%29是环境或自由变量的乐趣。对于外部库，返回的列表始终为空。以下元素仅在下列情况下出现在列表中Fun是当地的：{pid, Pid}Pid是最初创建乐趣的进程的进程标识符。{index, Index}Index%28 a整数%29是模块乐趣表的索引。{new_index, Index}Index%28 a整数%29是模块乐趣表的索引。{new_uniq, Uniq}Uniq%28a二进制%29是此乐趣的唯一值。它是根据整个模块的编译代码计算的。{uniq, Uniq}Uniq%28 a整数%29是此乐趣的唯一值。从Erlang/OTPR 15开始，这个整数是根据整个模块的编译代码计算的。在Erlang/OTP R15之前，这个整数只是基于主体的乐趣。Erlang：有趣[医]INFO%28 Fn，项目%29->{Item，Info}类型返回有关Fun如Item，在形式上{Item,Info}...为了好玩，Item可能是任何一个原子module，，，name，，，arity，，，env，或type...在当地找乐子，Item也可以是任何一个原子index，，，new_index，，，new_uniq，，，uniq，和pid.作为外部乐趣，这些项的值总是原子undefined...见erlang:fun_info/1...Erlang：有趣[医]到[医]列表%28 FUN%29->String%28%29类型返回与Fun...Erlang：功能[医]导出%28模块，函数，一致性%29->布尔值%28%29类型回报true如果模块Module加载并包含导出的函数。Function/Arity，或者如果有以指定名称在C%29中实现的bif%28a内置函数，则返回false...注此函数用于返回false在Erlang/OTP 18.0之前的BIF。垃圾[医]收集%28%29->真强制立即对正在执行的进程进行垃圾收集。除非注意到%28，否则不使用该函数，或者有充分的理由怀疑%29自发垃圾收集发生得太晚或根本不发生。警告不当使用会严重降低系统性能。垃圾[医]收集%28 Pid%29->GCResult类型同garbage_collect(Pid, [])...垃圾[医]收集%28 Pid，OptionList%29->GCResult异步类型垃圾收集由Pid...Option*{async, RequestId}功能garbage_collect/2返回值async在请求发出后立即。当请求被处理后，调用此函数的进程将在窗体上传递一条消息。{garbage_collect, RequestId, GCResult}...{type, 'major' | 'minor'}触发请求类型的垃圾收集。默认值是'major'会触发全扫描GC。选择'minor'被认为是一个提示，并可能导致次要或主要的GC运行。如果Pid等号self()，而不是async选项，垃圾回收将立即执行，即与调用相同。garbage_collect/0否则，垃圾收集请求将发送到Pid，并将在适当的时候处理。如果没有async选项已被传递，调用方将一直阻塞直到GCResult是可用的，并且可以返回。GCResult通知垃圾回收请求的结果如下：true所确定的过程Pid已经被收集起来了。false没有执行垃圾回收，因为Pid在请求得到满足之前终止。请注意，同样的警告也适用于garbage_collect/0...失败：badarg如果Pid不是节点本地进程标识符。badarg如果OptionList是无效的选项列表。得到%28%29->{KEY，Val}类型的列表返回进程字典。{Key, Val}例如，元组：> put(key1, merry), put(key2, lambs), put(key3, {are, playing}), get(). [{key1,merry},{key2,lambs},{key3,{are,playing}}]获取%28 Key%29->Val未定义类型返回值Val与Key在流程字典中，或undefined如果Key不存在。例子：> put(key1, merry), put(key2, lambs), put({any, [valid, term]}, {are, playing}), get({any, [valid, term]}). {are,playing}二郎：[医]Cookie%28%29->Cookie nocookie类型如果节点是活动的，则返回本地节点的神奇cookie，否则返回原子。nocookie...弄到[医]键%28%29->键类型返回进程字典中所有键的列表，例如：> put(dog, {animal,1}), put(cow, {animal,2}), put(lamb, {animal,3}), get_keys(). [dog,cow,lamb]弄到[医]键%28 Val%29->键类型返回与值关联的键列表。Val例如，在流程字典中：> put(mary, {1, 2}), put(had, {1, 2}), put(a, {1, 2}), put(little, {1, 2}), put(dog, {1, 3}), put(lamb, {1, 2}), get_keys({1, 2}). [mary,had,a,little,lamb]二郎：[医]堆栈跟踪%28%29->堆叠[医]项目%28%29类型获取调用堆栈返回跟踪%28。栈迹%29表示刚刚在调用进程中捕获的异常，该异常作为{Module,Function,Arity,Location}元组。场域Arity在第一个元组中，可以是该函数调用的参数列表，而不是一个依赖于异常的偶然性整数。如果进程中没有任何异常，则堆栈跟踪为[].在对进程进行代码更改后，还可以将堆栈跟踪重置为[]...erlang:get_stacktrace/0的范围内直接或间接地调用%28%29时，才保证返回堆栈跟踪。try表情。也就是说，以下调用工作：try Expr catch C:R -> {C,R,erlang:get_stacktrace()} end正如这一呼吁：try Expr catch C:R -> {C,R,helper()} end helper() -> erlang:get_stacktrace().警告在未来的发行版中，erlang:get_stacktrace/0会回来[]如果从外部调用try表情。堆栈跟踪是与运算符相同的数据。catch例如，返回：{'EXIT',{badarg,Stacktrace}} = catch abs(x)Location是%28，可能是空的%29列表，其中包含两个元组，可以指示函数的源代码中的位置。第一个元素是描述第二个元素中信息类型的原子。可出现以下项目：file元组的第二个元素是一个字符串%28，字符%29，表示函数源文件的文件名。line元组的第二个元素是源文件中发生异常或调用函数的行号%28a整数>0%29。另见error/1和error/2...群[医]领袖%28%29->PID%28%29返回用于评估函数的进程的组领导的流程标识符。每个进程都是某个进程组的成员，所有组都有一个组长.小组的所有I/O都传递给组长。当一个新的过程被产生时，它得到了与产卵过程相同的组领导。最初，在系统启动时，init既是它自己的组长，也是所有过程的组长。群[医]领导者%28组领袖PID%29->真类型设置小组组长Pid到GroupLeader通常，当从某个shell启动的流程有另一个组领导时，init...另见group_leader/0...停止%28%29->否[医]回报率%28%29同halt(0, []).例如：> halt(). os_prompt%停止%28状态%29->否[医]回报率%28%29类型同halt(Status, []).例如：> halt(17). os_prompt% echo $? 17 os_prompt%停止%28状态，选项%29->否[医]回报率%28%29类型Status必须是非负整数、字符串或原子。abort停止Erlang运行时系统。没有返回值。取决于Status，发生如下情况：整数%28%29运行时系统以整数值退出。Status作为调用环境%28OS%29的状态代码。注在许多平台上，操作系统只支持状态代码0-255。太大的状态码通过清除高位被截断。字符串%28%29生成了一个Erlang崩溃转储Status作为口号。然后，运行时系统将退出状态代码。1如果长度超过200个字符，则将截断字符串。注在ERTS 9.1%、28OTP-20.1%、29个之前，字符串中只接受0-255范围内的代码点。现在，任何Unicode字符串都是有效的。abort如果在操作系统中启用了核心转储，运行时系统将中止产生核心转储。整型Status，Erlang运行时系统关闭所有端口并允许异步线程在退出之前完成它们的操作。若要退出而不进行这种冲洗，请使用Option如{flush,false}...状态string()和abort，选项flush被忽略，而脸红是不完成了。HD%28 List%29->Term%28%29类型返回List，即第一个元素，例如：> hd([1,2,3,4,5]). 1被允许参加警卫测试。失败：badarg如果List是空列表[]...Erlang：Hibernate%28模块，功能，args%29->no[医]回报率%28%29类型将调用进程置于等待状态，其内存分配尽可能减少。如果进程不希望很快收到任何消息，这将非常有用。当消息被发送到进程时，进程会被唤醒，并在Module:Function指定的参数Args当调用堆栈清空时，意味着当该函数返回时进程将终止。因此erlang:hibernate/3永远不要回到它的呼叫者那里。如果进程的消息队列中有任何消息，则进程将立即以前面描述的方式唤醒。从更专业的角度来说，erlang:hibernate/3丢弃进程的调用堆栈，然后垃圾收集进程。在此之后，所有活动数据都在一个连续堆中。然后，堆缩小到与它保存的活数据%28完全相同的大小，即使该大小小于进程%29的最小堆大小。如果进程中的活动数据的大小小于最小堆大小，则在进程被唤醒后发生的第一次垃圾收集确保将堆大小更改为不小于最小堆大小的大小。请注意，清空调用堆栈意味着任何周围catch被移除，必须在冬眠后重新插入。其中一个效果是进程开始使用proc_lib%28也是间接的，例如gen_server进程%29，将使用proc_lib:hibernate/3相反，以确保异常处理程序在进程唤醒时继续工作。Erlang：插入[医]元素%28 Index，Tuple 1，Term%29->Tuple2类型1.元组[医]大小%28Tuple1%29+1返回带有元素的新元组。Term插入位置Index元组Tuple1.所有位置上的要素Index在新的元组中向上推高了一步Tuple2.例如：> erlang:insert_element(2, {one, two, three}, new). {one,new,two,three}整型[医]到[医]二进制%28整数%29->二进制%28%29类型返回对应于Integer，例如：> integer_to_binary(77). <<"77">>整型[医]到[医]二进制%28整数，基础%29->二进制%28%29类型返回对应于Integer在基地Base，例如：> integer_to_binary(1023, 16). <<"3FF">>整型[医]到[医]列表%28整数%29->字符串%28%29类型返回与Integer，例如：> integer_to_list(77). "77"整型[医]到[医]列表%28整数，基本%29->字符串%28%29类型返回与Integer在基地Base，例如：> integer_to_list(1023, 16). "3FF"尤利斯特[医]大小%28 Item%29->整数%28%29>=0类型返回一个整数，即二进制的大小(以字节为单位)，该整数是iolist_to_binary(Item)，例如：> iolist_size([1,2|<<3,4>>]). 4尤利斯特[医]到[医]二进制数%28 IoListOrbitics%29->二进制数%28%29类型中的整数和二进制文件生成的二进制文件。IoListOrBinary，例如：> Bin1 = <<1,2,3>>. <<1,2,3>> > Bin2 = <<4,5>>. <<4,5>> > Bin3 = <<6>>. <<6>> > iolist_to_binary([Bin1,1,[2,3,Bin2],4|Bin3]). <<1,2,3,1,2,3,4,5,4,6>>二郎：青年主义者[医]到[医]IOVEC%28 IoListOrB泌系%29->iovec()类型中的整数和二进制文件生成的iovec。IoListOrBinary...是[医]活着的%28%29->布尔值%28%29回报true如果本地节点是活动的%28，也就是说，如果节点可以是分布式系统%29的一部分，则为false...是[医]原子%28 Term%29->布尔值%28%29类型回报true如果Term是一个原子，否则false...被允许参加警卫测试。是[医]二进制%28 Term%29->布尔值%28%29类型回报true如果Term为二进制，否则为false...二进制文件总是包含完整的字节数。被允许参加警卫测试。是[医]位字符串%28 Term%29->布尔值%28%29类型回报true如果Term为位字符串%28，包括二进制%29，否则为false...被允许参加警卫测试。是[医]布尔值%28 Term%29->布尔值%28%29类型回报true如果Term是原子true或者原子false%28，即布尔值%29。否则返回false...被允许参加警卫测试。二郎：是[医]内置%28模块，函数，一致性%29->布尔值%28%29类型此BIF对于交叉引用工具的构建人员非常有用。回报true如果Module:Function/Arity是用C实现的BIF，则为false...是[医]浮点数%28 Term%29->布尔值%28%29类型回报true如果Term为浮点数，则为false...被允许参加警卫测试。是[医]函数%28 Term%29->布尔值%28%29类型回报true如果Term是一种乐趣，否则false...被允许参加警卫测试。是[医]函数%28 Term，重要性%29->布尔值%28%29类型回报true如果Term是一种可以应用于Arity参数数，否则为false...被允许参加警卫测试。是[医]整数%28 Term%29->布尔值%28%29类型回报true如果Term为整数，否则为false...被允许参加警卫测试。是[医]列表%28 Term%29->布尔值%28%29类型回报true如果Term为具有零或多个元素的列表，则为false...被允许参加警卫测试。是[医]映射%28 Term%29->布尔值%28%29类型回报true如果Term是一张地图，否则false...被允许参加警卫测试。是[医]数字%28 Term%29->布尔值%28%29类型回报true如果Term是整数或浮点数。否则返回false...被允许参加警卫测试。是[医]PID%28 Term%29->布尔值%28%29类型回报true如果Term是进程标识符，则为false...被允许参加警卫测试。是[医]端口%28 Term%29->布尔值%28%29类型回报true如果Term为端口标识符，则为false...被允许参加警卫测试。是[医]加工过程[医]活%28 Pid%29->布尔值%28%29类型Pid必须引用本地节点上的进程。回报true如果进程存在并且是活着的，也就是说，不退出也没有退出。否则返回false...是[医]记录%28 Term，记录Tag%29->布尔值%28%29类型回报true如果Term是一个元组，其第一个元素是RecordTag.否则返回false...注通常，编译器处理对is_record/2尤其是。它会发出代码来验证Term是一个元组，它的第一个元素是RecordTag大小是正确的。但是，如果RecordTag不是文字原子，BIFis_record/2将被调用，并且不验证元组的大小。允许在警卫测试中，如果RecordTag是一个字面上的原子。是[医]记录%28 Term，记录标签，大小%29->布尔值%28%29类型RecordTag一定是原子。回报true如果Term是一个元组，它的第一个元素是RecordTag，它的大小是Size.否则返回false...允许在警卫测试中RecordTag是一个字面上的原子Size是一个字面整数。注为了完整起见，本文记录了此BIF。通常is_record/2就是被利用。是[医]引用%28 Term%29->布尔值%28%29类型回报true如果Term是引用，否则为false...被允许参加警卫测试。是[医]元组%28 Term%29->布尔值%28%29类型回报true如果Term是元组，否则false...被允许参加警卫测试。长度%28 List%29->整数%28%29>=0类型返回List，例如：> length([1,2,3,4,5,6,7,8,9]). 9被允许参加警卫测试。链接%28 PidOrport%29->true类型在调用进程与另一个进程%28或端口%29之间创建一个链接PidOrPort，如果已经没有这样的联系的话。如果一个进程试图创建到自身的链接，则不会执行任何操作。回报true...如果PidOrPort不存在，BIF的行为取决于调用进程是否正在捕获退出或未捕获%28(参见process_flag/229%：

• 如果调用过程没有陷入退出，并且检查PidOrPort很便宜（即，如果PidOrPort是本地），则link/1失败并且有理由noproc。

• 否则，如果调用进程陷阱退出，并且/或者PidOrPort是远程的，则link/1返回true，但带有原因的退出信号noproc被发送到调用进程。

list_to_atom(String) -> atom()

类型

返回文本表示的原子String。

从Erlang / OTP 20开始，String可能包含任何Unicode字符。早期版本只允许使用ISO-latin-1字符，因为该实现不允许高于255的Unicode字符。有关原子中Unicode支持的更多信息，请参见note on UTF-8 encoded atoms用户指南中的“外部术​​语格式”一节。

例子：

> list_to_atom("Erlang").
'Erlang'

list_to_binary(IoList) -> binary()

类型

返回由整数和二进制文件构成的二进制文件IoList，例如：

> Bin1 = <<1,2,3>>.
<<1,2,3>>
> Bin2 = <<4,5>>.
<<4,5>>
> Bin3 = <<6>>.
<<6>>
> list_to_binary([Bin1,1,[2,3,Bin2],4|Bin3]).
<<1,2,3,1,2,3,4,5,4,6>>

list_to_bitstring(BitstringList) -> bitstring()

类型

返回由整数和位串组成的位串BitstringList。（BitstringList允许最后一个尾部是比特串）例如：

> Bin1 = <<1,2,3>>.
<<1,2,3>>
> Bin2 = <<4,5>>.
<<4,5>>
> Bin3 = <<6,7:4>>.
<<6,7:4>>
> list_to_bitstring([Bin1,1,[2,3,Bin2],4|Bin3]).
<<1,2,3,1,2,3,4,5,4,6,7:4>>

list_to_existing_atom(String) -> atom()

类型

返回其文本表示的原子String，但仅当已经存在此类原子时才返回。

失败：badarg如果不存在其文本表示的原子String。

注

请注意，编译器可能会优化掉原子。例如，编译器将重写atom_to_list(some_atom)为"some_atom"。如果该表达式是some_atom包含模块中唯一提及的原子，则在模块加载时不会创建原子，并且随后的调用list_to_existing_atom("some_atom")将失败。

list_to_float(String) -> float()

类型

返回其文本表示形式为的float String，例如：

> list_to_float("2.2017764e+0").
2.2017764

失败：badarg如果String包含浮动的错误表示形式。

list_to_integer(String) -> integer()

类型

返回文本表示为String，例如：

> list_to_integer("123").
123

失败：badarg如果String包含整数的错误表示形式。

list_to_integer(String, Base) -> integer()

类型

返回以基表示文本的整数。Base是String，例如：

> list_to_integer("3FF", 16).
1023

失败：badarg如果String包含整数的错误表示形式。

list_to_pid(String) -> pid()

类型

返回一个进程标识符，该标识符的文本表示形式为String，例如：

> list_to_pid("<0.4.1>").
<0.4.1>

失败：badarg如果String包含进程标识符的错误表示形式。

警告

此BIF用于调试，不用于应用程序。

list_to_port(String) -> port()

类型

返回一个端口标识符，其文本表示形式为String，例如：

> list_to_port("#Port<0.4>").
#Port<0.4>

失败：badarg如果String包含端口标识符的错误表示形式。

警告

此BIF用于调试，不用于应用程序。

list_to_ref(String) -> reference()

类型

返回文本表示形式为String，例如：

> list_to_ref("#Ref<0.4192537678.4073193475.71181>").
#Ref<0.4192537678.4073193475.71181>

失败：badarg如果String包含引用的错误表示形式。

警告

此BIF用于调试，不用于应用程序。

list_to_tuple(List) -> tuple()

类型

返回对应于List，例如

> list_to_tuple([share, ['Ericsson_B', 163]]).
{share, ['Ericsson_B', 163]}

List可以包含任何Erlang术语。

load_module(Module, Binary) -> {module, Module} | {error, Reason}

类型

如果Binary包含模块的目标代码Module，则此BIF加载该目标代码。如果模块的代码Module已经存在，所有的导出引用都被替换，所以它们指向新加载的代码。先前加载的代码作为旧代码保存在系统中，因为仍可能有执行该代码的进程。

返回{module, Module}，或{error, Reason}如果加载失败。Reason为下列之一：

badfile中的目标代码Binary格式不正确或对象代码包含以下模块的代码：Module...not_purgedBinary包含无法加载的模块，因为该模块的旧代码已经存在。

警告

这个BIF用于代码服务器（见code(3)），不用于其他地方。

erlang:load_nif(Path, LoadInfo) -> ok | Error

类型

加载并链接包含模块的本地实现函数（NIF）的动态库。Path是共享对象/动态库文件的文件路径减去操作系统相关的文件扩展名（.so适用于Unix和.dllWindows）。请注意，在大多数操作系统上，当nif升级完成时，磁带库必须具有不同的光盘名称。如果名称相同，但内容不同，则可以装入旧库。有关如何实现NIF库的信息，请参阅erl_nif(3)。

LoadInfo可以是任何术语。作为初始化的一部分，它被传递到库中。一个好的做法是包括一个模块版本号，以支持未来的代码升级方案。

调用load_nif/2必须直接从NIF库所属的模块的Erlang代码中进行。它会返回ok，或者{error,{Reason,Text}}如果加载失败。Reason是以下原子之一，同时Text是一个可读的字符串，可以提供有关失败的更多信息：

load_failed操作系统无法加载NIF库。 bad_lib该库没有满足作为调用模块的NIF库的要求。 load | upgrade相应的库回调失败。 reloadNIF库已经为这个模块实例加载。先前弃用的reload功能在OTP 20中被删除 old_code。调用load_nif/2来自已升级模块的旧代码; 这是不允许的。 notsup缺乏支持。比如为HiPE编译模块加载NIF库。

erlang:loaded() -> Module

类型

返回所有加载的Erlang模块（当前和旧代码）的列表，包括预加载的模块。

另见code(3)...

erlang:localtime() -> DateTime

类型

返回当前的本地日期和时间，{{Year, Month, Day}, {Hour, Minute, Second}}例如：

> erlang:localtime().
{{1996,11,6},{14,45,17}}

时区和夏令时校正取决于底层操作系统。

erlang:localtime_to_universaltime(Localtime) -> Universaltime

类型

如果基础操作系统支持，则将本地日期和时间转换为协调世界时（UTC）。否则，没有转换完成并返回Localtime。例：

> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}).
{{1996,11,6},{13,45,17}}

失败：badarg如果Localtime表示无效的日期和时间。

erlang:localtime_to_universaltime(Localtime, IsDst) ->

宇宙时间

类型

将本地日期和时间转换为协调世界时（UTC）erlang:localtime_to_universaltime/1，但呼叫方决定是否启用夏令时。

如果IsDst == true，Localtime是夏令时期间，如果IsDst == false事实并非如此。如果IsDst == undefined，底层操作系统可以猜测，这与调用erlang:localtime_to_universaltime(Localtime)相同。

例子：

> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}, true).
{{1996,11,6},{12,45,17}}
> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}, false).
{{1996,11,6},{13,45,17}}
> erlang:localtime_to_universaltime({{1996,11,6},{14,45,17}}, undefined).
{{1996,11,6},{13,45,17}}

失败：badarg如果Localtime表示无效的日期和时间。

make_ref() -> reference()

返回unique reference。该参考在连接的节点中是唯一的。

警告

已知问题：当一个节点用同一个节点名称重新启动多次时，在较新节点上创建的引用可能被误认为是在具有相同节点名称的旧节点上创建的引用。

erlang:make_tuple(Arity, InitialValue) -> tuple()

类型

创建指定的新元组Arity，其中所有元素都是InitialValue，例如：

> erlang:make_tuple(4, []).
{[],[],[],[]}

erlang:make_tuple(Arity, DefaultValue, InitList) -> tuple()

类型

创建一个大小的元组Arity，其中每个元素都有值DefaultValue，然后从中填充值InitList。每个列表元素InitList必须是一个二元组，其中第一个元素是新创建的元组中的一个位置，第二个元素是任何项。如果一个位置在列表中出现多次，则使用与最后一次出现相对应的术语。例：

> erlang:make_tuple(5, [], [{2,ignored},{5,zz},{2,aa}]).
{[],aa,[],[],zz}

map_size(Map) -> integer() >= 0

类型

返回一个整数，它是Map，例如：

> map_size(#{a=>1, b=>2, c=>3}).
3

允许在when模式匹配下使用

erlang:match_spec_test(MatchAgainst, MatchSpec, Type) ->

测试结果

类型

测试调用中使用的匹配规范ets:select/2和erlang:trace_pattern/3。该函数测试“语法”正确性的匹配规范，并针对该对象运行匹配规范。如果匹配规范包含错误，{error, Errors}则返回元组，其中Errors是匹配规范错误的自然语言描述列表。

如果Type是table，匹配的对象是一个元组。函数然后返回{ok,Result,[],Warnings}，其中Result是true，ets:select/2调用的结果，或者false匹配规范是否与对象元组不匹配。

如果Type是trace，匹配的对象是一个列表。函数返回{ok, Result, Flags, Warnings}，其中Result是下列之一：

• true如果要发出跟踪消息

• false如果不发出跟踪消息

• 要附加到跟踪消息的消息项。

Flags是一个包含所有要启用的跟踪标志的列表，目前这只是return_trace。

这是一个有用的调试和测试工具，特别是在编写复杂的匹配规范时。

另见ets:test_ms/2...

max(Term1, Term2) -> Maximum

类型

返回最大的Term1和Term2如果条件相等，Term1会被返回。

erlang:md5(Data) -> Digest

类型

计算摘要Data长度为128位（16字节）的MD5消息摘要。Data是一个二进制文件或一个小整数和二进制文件的列表。

有关md5的详细信息，请参阅RFC 1321 - The MD5 Message-Digest Algorithm...

警告

MD5消息摘要算法是不被认为是安全的代码签名或软件完整性的目的。

erlang:md5_final(Context) -> Digest

类型

完成MD5的更新Context并返回计算的MD5消息摘要。

erlang:md5_init() -> Context

类型

创建MD5上下文，用于以下调用md5_update/2...

erlang:md5_update(Context, Data) -> NewContext

类型

更新MD5 Context与Data和返回NewContext。

erlang:memory() -> {Type, Size}

类型

返回一个列表，其中包含Erlang仿真器动态分配的内存信息。每个列表元素都是一个元组{Type, Size}。第一个元素Type是描述内存类型的原子。第二个元素Size是以字节为单位的内存大小。

内存类型：

total

当前分配的内存总量。这是一样的内存大小为总和processes和system。

processes

当前分配给Erlang进程的内存总量。

processes_used

Erlang进程当前使用的内存总量。这是表示为processes内存。

system

当前分配给模拟器的内存总量，与任何Erlang进程没有直接关系。显示为processes不在此内存中。

atom

当前分配给原子的内存总量。此内存是表示为system内存。

atom_used

当前用于原子的内存总量。此内存是表示为atom内存。

binary

当前分配给二进制文件的内存总量。此内存是表示为system内存

code

当前分配给Erlang代码的内存总量。此内存是表示为system内存

ets

当前分配给ETS表的内存总量。此内存是表示为system内存

low

只在64位半字仿真器上。在限制为<4GB的低内存区域中分配的内存总量，尽管系统可以有更多的内存。

可以在以后的半字仿真器版本中删除。

maximum

自模拟器启动以来分配的最大内存总量。此元组仅在使用仪表运行仿真程序时才会出现。

有关如何使用检测来运行模拟器的信息，请参阅instrument(3)和/或erl(1)。

注

该system值是不完整的。一些分配的内存将成为该值的一部分不是。

当使用工具运行模拟器时，系统值更准确，但直接为malloc（和朋友）分配的内存仍不是系统值的一部分。 直接调用malloc只能从特定于操作系统的运行时库中完成，也可能从用户实现的不使用驱动程序接口中的内存分配函数的Erlang驱动程序完成。

由于total值是总和processes和system，在该错误system传播到total的值。

求和的内存的不同数量不会以原子方式收集，这会在结果中引入错误。

不同的值之间有如下关系。以大写字母开头的值不是结果的一部分。

total      = processes + system
processes  = processes_used + ProcessesNotUsed
system     = atom + binary + code + ets + OtherSystem
atom       = atom_used + AtomNotUsed
RealTotal  = processes + RealSystem
RealSystem = system + MissedSystem

返回列表中的更多元组可以在以后的版本中添加。

注

该total值应该是由仿真器动态分配的总内存量。共享库，仿真器本身的代码和仿真器堆栈不应包含在内。也就是说，该total值不应该等于映射到模拟器的所有页面的总大小。

此外，由于内存区域的分割和预存储，包含动态分配的内存块的内存段的大小可能比动态分配的内存块的总大小大得多。

注

从ERTS 5.6.4开始，erlang:memory/0要求erts_alloc(3)启用所有分配器（默认行为）。

失败：notsup如果erts_alloc(3)分配程序已被禁用。

erlang:memory(Type :: memory_type()) -> integer() >= 0

erlang:memory(TypeList :: memory_type()) ->

{memory_type(), integer() >= 0}

类型

返回分配给内存类型的内存大小（以字节为单位）Type。该参数也可以被指定为一个memory_type()原子列表，在这种情况下{memory_type(), Size :: integer >= 0}返回一个相应的元组列表。

注

从ERTS 5.6.4开始，erlang:memory/1要求erts_alloc(3)启用所有分配器（默认行为）。

失败：

badarg 如果Type不是描述中列出的内存类型之一erlang:memory/0。

badarg 如果maximum通过Type并且模拟器未在仪表模式下运行。

notsup 如果erts_alloc(3)分配器已被禁用。

另见erlang:memory/0...

min(Term1, Term2) -> Minimum

类型

返回Term1和中的最小值Term2。如果条款相同，则返回Term1

module_loaded(Module) -> boolean()

类型

返回true模块Module是否加载，否则返回false。它不会尝试加载模块。

警告

这个BIF用于代码服务器（见code(3)），不用于其他地方。

monitor（Type :: process，Item :: monitor_process_identifier（）） - >

MonitorRef

monitor（Type :: port，Item :: monitor_port_identifier（）） - >

MonitorRef

monitor（Type :: time_offset，Item :: clock_service） - > MonitorRef

类型

将类型的监视器请求发送Type到由标识的实体Item。如果被监控的实体不存在或者它改变监控状态，monitor/2则通过以下格式的消息来通知呼叫者：

{Tag, MonitorRef, Type, Object, Info}

注

监视器请求是一个异步信号。也就是说，信号到达目的地需要时间。

Type可以是下列原子之一：process，port或time_offset。

process或port监控器只会触发一次，然后从监控进程和被监控实体中删除。监视的进程或端口终止时，监视器被触发，创建时不存在，或者连接丢失。如果与它的连接丢失，我们不知道它是否仍然存在。demonitor/1调用时，监控也被关闭。

process或port按名称监视器在监视器实例化时解析RegisteredName为pid()或port()仅一次，稍后更改名称注册将不会影响现有监视器。

当process或port监视器被触发，'DOWN'发送的消息具有以下模式：

{'DOWN', MonitorRef, Type, Object, Info}

在监视器消息中MonitorRef和Type与前面描述的相同，并且：

Object

被监控的实体触发了该事件。监视本地进程或端口时，Object将等于pid()或port()正在监视。当按名称监视进程或端口时，Object将具有格式{RegisteredName, Node}，其中RegisteredName是monitor/2调用使用的名称，并且Node是本地或远程节点名称（对于受名称监视的端口，Node始终是本地节点名称）。

Info

流程的退出原因noproc（流程或端口在创建监视器时不存在）或noconnection（与监视的流程所在的节点没有连接）。

如果尝试监视较旧节点上的进程（未实现远程进程监视或未实现通过注册名称进行远程进程监视），则调用失败，并且badarg。

注

'DOWN'ERTS 5.2（Erlang / OTP R9B）中的消息格式在注册名称中进行了监控。在早期版本Object中，'DOWN'消息的元素有时可能是受监视进程的进程标识符，有时也可能是已注册的名称。现在元素Object总是一个由注册名称和节点名组成的元组。新节点（ERTS 5.2或更高版本）'DOWN'上的进程始终以新格式获取消息，即使它们正在监视旧节点上的进程。旧节点'DOWN'上的进程总是以旧格式获取消息。

监控一个 process

在当前进程和由其标识的另一个进程之间创建监视器，该进程Item可以是pid()（本地或远程），也可以是位于其他位置的已注册进程的原子RegisteredName或元组{RegisteredName, Node}。

监控 port

在当前进程和由其标识的端口之间创建监视器，该端口Item可以是位于此节点上的port()（仅本地），注册端口的原子RegisteredName或元组{RegisteredName, Node}。请注意，尝试监视远程端口将导致badarg。

监控 time_offset

监视和time offset之间的变化。一个有效的与原子结合存在，即原子。请注意，该原子是不进程的注册名称。在这种情况下，它用作当前运行时系统实例中的运行时系统内部时钟服务的标识符。Erlang monotonic timeErlang system timeItemtime_offset Typeclock_serviceclock_service

当时间偏移改变时，监视器被触发。这或者如果所述时间偏移值被改变，或者如果在该偏移是从初步到最终改变finalization of the time offset的时single time warp mode被使用。当从初始时间到最终时间偏移发生变化时，无论时间偏移值是否更改，监视器都会被触发一次。

如果运行系统处于运行状态multi time warp mode，则当运行系统检测到已更改时，时间偏移会更改OS system time。但是，运行时系统在发生时不会立即检测到它。检查时间偏移的任务每分钟计划至少执行一次，因此在正常操作下，这些操作会在一分钟内检测到，但在重负载期间可能需要较长的时间。

监视器是不被触发后自动删除。也就是说，时间偏移的重复变化会反复触发监视器。

当监视器被触发时，'CHANGE'消息被发送到监视进程。'CHANGE'消息有以下模式：

{'CHANGE', MonitorRef, Type, Item, NewTimeOffset}

其中MonitorRef，Type和Item如上所述相同，并且NewTimeOffset是新的时间偏移量。

当'CHANGE'已收到消息，您将保证在调用时不会检索旧的时间偏移量。erlang:time_offset()请注意，您可以在调用时观察时间偏移量的变化。erlang:time_offset()在你拿到'CHANGE'留言。

制作多次调用monitor/2在相同的Item和/或Type不是一个错误; 它会产生尽可能多的独立监控实例。

预计将扩展监视器功能。那就是，其他TypeS和Item预期在未来的版本中将支持S。

注

如果或者当monitor/2延伸时，其他可能的值Tag，Object以及Info在监视器消息将被引入。

monitor_node(Node, Flag) -> true

类型

监视节点的状态Node。如果Flag是true，则打开监视。如果Flag是false，则关闭监控。

几次调用monitor_node(Node, true)为了同样的Node不是一个错误；它会导致同样多的独立监视实例。

如果节点失败或不存在，则将消息{nodedown，Node}传递给进程。 如果进程对monitor_node（Node，true）进行了两次调用，并且节点终止，则将两个nodedown消息传递给该进程。 如果没有连接到节点，则尝试创建一个节点。 如果失败，则传递一个nodedown消息。

通过隐藏连接连接的节点可以作为任何其他节点进行监视。

失败：badarg如果本地节点没有活动。

erlang:monitor_node(Node, Flag, Options) -> true

类型

表现为monitor_node / 2，只是它允许指定一个额外的选项，即allow_passive_connect。 此选项允许BIF等待正常的网络连接超时，以便受监视的节点自行连接，即使它不能从该节点主动连接（即被阻止）。 只有通过使用内核选项dist_auto_connect一次才能实现可以使用的状态。 如果没有使用该选项，则选项allow_passive_connect不起作用。

注

Option allow_passive_connect在内部使用，并且在事先已知网络拓扑和内核选项有效的应用程序中很少需要。

失败：badarg 如果本地节点未激活或选项列表格式错误。

erlang:monotonic_time() -> integer()

以本地时间单位返回当前Erlang单调时间。 这是一段时间以来单调递增的时间。

注

这是一个monotonically increasing时间，但是strictly monotonically increasing时间到了。也就是说，连续调用erlang:monotonic_time/0也能产生同样的结果。

不同的运行时系统实例将使用不同的未指定时间点作为其Erlang单调时钟的基础。也就是说，比较来自不同运行时间系统实例的单调时间毫无意义。不同的运行时系统实例也可以将这个未指定的时间点放在不同的相对运行时系统启动时。它可以放在未来（开始时的时间为负值），过去的时间（开始时的时间为正值）或运行时系统启动（开始时的时间为零）。运行时系统启动时的单调时间可以通过调用来检索erlang:system_info(start_time)。

erlang:monotonic_time(Unit) -> integer()

类型

返回Erlang monotonic time转换为Unit传递参数的当前值。

类似于调用erlang:convert_time_unit(erlang:monotonic_time(), native, Unit)，但是为常用的Units 优化。

erlang：nif_error（原因） - > no_return（）

类型

如error/1，但Dialyzer认为这个BIF将返回一个任意的术语。当NIF库的存根函数用于NIF生成异常时，Dialyzer不会生成错误的警告。

erlang:nif_error(Reason, Args) -> no_return()

类型

如error/2，但Dialyzer认为这个BIF将返回一个任意的术语。当NIF库的存根函数用于NIF生成异常时，Dialyzer不会生成错误的警告。

node() -> Node

类型

返回本地节点的名称。如果节点没有活动，而是返回nonode@nohost。

允许在when模式匹配下使用

node(Arg) -> Node

类型

返回Arg起源的节点。Arg可以是进程标识符，引用或端口。如果本地节点不活动，nonode@nohost则被返回。

允许在when模式匹配下使用

nodes() -> Nodes

类型

返回系统中除本地节点外的所有可见节点的列表。如nodes(visible)。

nodes(Arg) -> Nodes

类型

根据指定的参数返回节点列表。当参数是一个列表时，返回的结果是满足列表元素的分离的节点列表。

NodeTypes：

visible

通过正常连接连接到此节点的节点。

hidden

通过隐藏连接连接到此节点的节点。

connected

连接到此节点的所有节点。

this

这个节点。

known

此节点已知的节点。也就是说，由位于此节点上的进程标识符、端口标识符和引用所引用的连接节点和节点。已知节点集是垃圾收集的。注意，垃圾回收可能会延迟。有关更多信息，请参见erlang:system_info(delayed_node_table_gc)...

一些等值：[node()] = nodes(this)，nodes(connected) = nodes([visible, hidden])，和nodes() = nodes(visible)

now() -> Timestamp

类型

警告

此功能已弃用。不要使用它。

有关更多信息，请参阅Time and Time Correction用户指南中的部分。具体来说，部分Dos and Dont's描述了用什么来代替erlang:now/0。

返回元组{MegaSecs, Secs, MicroSecs}，这是从1970年1月1日00:00 GMT（零时）开始经过的时间，如果由底层操作系统提供。否则，选择其他时间点。还保证以下对该BIF的呼叫不断增加价值。因此，来自返回值erlang:now/0可用于生成唯一的时间戳。如果在快速机器上以紧密的方式调用它，则节点的时间可能会偏斜。

如果底层操作系统的时区信息已正确配置，则只能用于检查当地时间。

open_port(PortName, PortSettings) -> port()

类型

由于打开一个新的Erlang端口，返回一个端口标识符。一个端口可以被看作是一个外部的Erlang进程。

该可执行文件的名称以及参数specifed中cd，env，args，和arg0如果系统以Unicode文件名模式下运行受到的Unicode文件名翻译。为了避免翻译或强制，例如UTF-8，请将可执行文件和/或参数作为正确编码的二进制文件提供。有关详细信息，请参阅模块file(3)，file:native_name_encoding/0内核中的功能和Using Unicode in Erlang用户指南。

注

如果Erlang虚拟机以Unicode文件名翻译模式启动，则名称中的字符（如果指定为列表）只能大于255。否则，可执行文件的名称仅限于ISO Latin-1字符集。

PortNames：

{spawn, Command}

开始一个外部程序。Command是要运行的外部程序的名称。Command在Erlang工作空间之外运行，除非Command找到具有该名称的Erlang驱动程序。如果找到，则启动该驱动程序。驱动程序运行在Erlang工作区中，这意味着它与Erlang运行时系统链接。

在Solaris上启动外部程序时，系统调用vfork优先使用fork，但出于性能方面的考虑，尽管它具有较差的历史记录。如果使用中存在问题vfork，则将环境变量设置ERL_NO_VFORK为任何值都会导致fork被使用。

对于外部程序，PATH搜索（或根据操作系统使用等效方法查找程序）。这是通过在某些平台上调用shell来完成的。该命令的第一个空格分隔标记被视为可执行文件（或驱动程序）的名称。这（除别的以外）使得这个选项不适合用文件名或目录名称中的空格运行程序。如果需要可执行文件名中的空格，请改为使用{spawn_executable, Command}。

{spawn_driver, Command}

如{spawn, Command}，但要求命令的第一个（空格分隔的）标记是加载的驱动程序的名称。如果没有装载该名称的驱动程序，badarg则会引发错误。

{spawn_executable, FileName}

如{spawn, FileName}，但只运行外部可执行文件。FileName在其整体上用作可执行文件的名称，包括任何空格。如果参数是要传递中，PortSettings args并arg0可以使用。

通常不会调用shell来启动程序，它直接执行。PATH（或等效）不被搜索。要找到PATH要执行的程序，请使用os:find_executable/1。

只有在执行shell脚本或.bat文件时，才会隐式调用相应的命令解释程序，但仍不存在命令参数扩展或隐式PATH搜索。

如果FileName无法运行，则会引发错误异常，并以POSIX错误代码为原因。操作系统之间的错误原因可能不同。通常，enoent当尝试运行未找到的程序并eacces在指定文件不可执行时引发程序时，会引发错误。

{fd, In, Out}

允许Erlang进程访问Erlang使用的任何当前打开的文件描述符。文件描述符In可用于标准输入，文件描述符Out用于标准输出。它仅用于Erlang OS（shell和user）中的各种服务器。因此，它的使用是有限的。

PortSettings是端口设置的列表。有效设置如下：

{packet, N}

消息前面是它们的长度，以N字节为单位发送，最重要的字节在前。有效值为N1,2和4。

stream

输出消息的发送没有数据包长度。用户定义的协议必须在Erlang进程和外部对象之间使用。

{line, L}

消息以每行为基础递送。每行（由依赖于操作系统的换行符序列定界）以单个消息发送。消息数据格式是{Flag, Line}，或者Flag是，并且是已传送的数据（不包括换行符序列）。eolnoeolLine

L以字节为单位指定最大行长度。 比这更长的行被传递到多条消息中，标志设置为noeol而不是最后一条消息。 如果在其他地方遇到文件结尾而不是紧跟在换行符之后，则最后一行也会将标志设置为noeol。 否则，交付的标志设置为eol。

在{packet, N}和{line, L}设置相互排斥。

{cd, Dir}

只适用于{spawn, Command}和{spawn_executable, FileName}。外部程序开始Dir用作其工作目录。Dir必须是一个字符串。

{env, Env}

只适用于{spawn, Command}和{spawn_executable, FileName}。启动过程的环境使用中的环境规范进行了扩展Env。

Env是一个元组列表{Name，Val}，其中Name是环境变量的名称，Val是它在生成的端口进程中的值。 Name和Val都必须是字符串。 Val是原子假的一个例外（类似于os：getenv / 1，它删除了环境变量。

{args, [ string() | binary() ]}

仅对{spawn_executable, FileName}可执行文件有效并指定参数。每个参数都被指定为一个单独的字符串，并且（在Unix上）最终作为参数向量中的一个元素结束。在其他平台上，类似的行为是模仿的。

在提供给可执行文件之前，参数不会被shell展开。最值得注意的是这意味着文件通配符扩展不会发生。要扩展参数的通配符，请使用filelib:wildcard/1。请注意，即使程序是Unix shell脚本，也就是说shell最终被调用，通配符扩展不会发生，并且该脚本提供了未触及的参数。在Windows上，通配符扩展总是取决于程序本身，因此这不是问题。

可执行文件名称（也称为argv[0]）不在此列表中指定。argv[0]适用时，将自动使用适当的可执行文件名称。

如果您明确要在参数向量中设置程序名称，arg0可以使用选项。

{arg0, string() | binary()}

只有{spawn_executable, FileName}在运行可执行文件时有效且明确指定程序名称参数。在某些情况下，这在某些操作系统中可能是可取的。程序如何响应这个问题是高度依赖系统的，并且没有保证具体的效果。

exit_status

只适用于{spawn, Command}，Command指的是外部程序，以及{spawn_executable, FileName}。

当连接到端口的外部进程退出时，表单消息将{Port,{exit_status,Status}}发送到连接的进程，其中Status是外部进程的退出状态。如果程序在Unix上中止，则使用与shell相同的约定（即128 +信号）。

如果选项eof也被指定，消息eof与exit_status出现在未指定的顺序。

如果端口程序关闭其stdout不退出，选择exit_status不起作用。

use_stdio

只适用于{spawn, Command}和{spawn_executable, FileName}。它允许生成的（Unix）进程的标准输入和输出（文件描述符0和1）与Erlang进行通信。

nouse_stdio

与之相反，use_stdio使用文件描述符3和4与Erlang进行通信。

stderr_to_stdout

影响外部程序的端口。执行的程序将其标准错误文件重定向到其标准输出文件。stderr_to_stdout和nouse_stdio是相互排斥的。

overlapped_io

仅在Windows上影响端口到外部程序。如果提供此选项，则端口程序的标准输入和标准输出句柄将以标志打开FILE_FLAG_OVERLAPPED，以便端口程序可以（并且必须）在其标准句柄上执行重叠的I / O。这对于简单的端口程序通常不是这种情况，而是有经验的Windows程序员的一种选择。在所有其他平台上，此选项将被默默丢弃。

in

端口只能用于输入。

out

端口只能用于输出。

binary

端口的所有I/O都是二进制数据对象，而不是字节列表。

eof

端口在文件末尾没有关闭，也不会产生退出信号。相反，它保持打开，并且{Port, eof}消息被发送到持有端口的进程。

hide

在Windows上运行时，禁止在产生端口程序时创建新的控制台窗口。（该选项对其他平台没有影响。）

{parallelism, Boolean}

为端口并行设置调度程序提示。如果设置为true，则虚拟机调度端口任务; 这样做时，它可以提高系统的并行性。如果设置为false，则虚拟机会立即尝试执行端口任务，从而以牺牲并行性为代价来提高延迟。默认可以在系统启动时通过命令行参数设置+spp到erl(1)。

默认值是stream所有端口类型和use_stdio为产生的端口。

失败：如果无法打开端口，则退出原因是badarg，system_limit或最接近描述该错误的POSIX错误代码，或者einval如果没有适当的POSIX代码：

badarg输入参数错误open_port。 system_limitErlang仿真器中的所有可用端口都在使用中。 enomem没有足够的内存来创建端口。 eagain没有更多可用的OS进程。 enametoolong外部命令太长。 emfile没有更多可用的文件描述符（用于运行Erlang模拟器的OS进程）。 enfile全文件表（适用于整个操作系统）。 在指定中没有指出可执行文件。 在中指定并不指出现有文件。 eacces Command{spawn_executable, Command}enoent FileName{spawn_executable, FileName}

在使用打开的端口使用{spawn, Name}，，{spawn_driver, Name}或{spawn_executable, Name}发送消息时出现的错误通过表单信号向拥有进程报告{'EXIT', Port, PosixCode}。有关可能的值PosixCode，请参阅file(3)。

可以通过传递命令行标志+Q来配置可以同时打开的最大端口数erl(1)。

erlang:phash(Term, Range) -> Hash

类型

Range = 1..2^32, Hash = 1..Range

便携式哈希函数为相同的Erlang术语提供相同的哈希，而不管机器体系结构和ERTS版本（BIF是在ERTS 4.9.1.1中引入的）。该函数返回Term范围内的散列值1..Range。最大值为Range2 ^ 32。

erlang:phash2(Term) -> Hash

erlang:phash2(Term, Range) -> Hash

类型

1.2^32

0..Range-1

便携式哈希函数为相同的Erlang术语提供相同的哈希值，而不管机器体系结构和ERTS版本（BIF是在ERTS 5.2中引入的）。该函数返回Term范围内的散列值0..Range-1。最大值为Range2 ^ 32。如果没有参数Range，则返回0..2 ^ 27-1范围内的值。

这个BIF总是用于散列术语。它比小phash/2分子更好地分布，而且它对于双子和双星来说速度更快。

请注意，范围与范围0..Range-1是不同的phash/2，这是1..Range。

pid_to_list(Pid) -> string()

类型

返回对应于文本表示的字符串Pid。

erlang:port_call(Port, Operation, Data) -> term()

类型

执行到端口的同步呼叫。 操作和数据的含义取决于端口，即端口驱动程序。 并非所有端口驱动程序都支持此功能

Port是一个端口标识符，引用了驱动程序。

Operation是一个整数，它将传递给驱动程序。

Data是任何Erlang术语。此数据被转换为二进制术语格式并发送到端口。

从驱动程序返回一个术语。返回数据的含义也取决于端口驱动程序。

失败：

badarg 如果Port不是开放端口的标识符或开放端口的注册名称。如果调用进程先前已链接到由端口标识的封闭端口，Port则保证在该badarg异常发生之前传送来自端口的退出信号。 badarg 如果Operation不适合32位整数。

badarg 如果端口驱动程序不支持同步控制操作。

badarg 如果端口驱动程序因此而作出任何决定（可能是Operationor的错误Data）。

port_close(Port) -> true

类型

关闭一个开放的端口。同于Port ! {self(), close}，除了错误行为（见下文），是同步的，并且该端口也不会与回复{Port, closed}。任何进程都可以关闭一个端口port_close/1，而不仅仅是端口所有者（连接的进程）。如果呼叫过程链接到由端口标识的端口Port，则来自端口的出口信号保证在port_close/1返回之前交付。

对于比较：Port ! {self(), close}只有失败，badarg如果Port不是指一个端口或过程。如果Port是封闭的端口，则什么都不会发生。如果Port是一个开放端口，并且调用进程是端口所有者，则{Port, closed}当所有缓冲区已被刷新并且端口真正关闭时，端口将进行回复。如果调用进程不是端口所有者，端口所有者将失败

注意，任何进程都可以使用Port ! {PortOwner, close}就好像它本身就是端口所有者，但是回复总是传递给端口所有者。

从Erlang / OTP R16开始，Port ! {PortOwner, close}它确实是异步的。请注意，此操作始终被记录为异步操作，而底层实现已同步。但port_close/1由于其错误行为仍然完全同步。

失败：badarg

如果Port不是开放端口的标识符或开放端口的注册名称。如果调用进程先前已链接到由端口标识的封闭端口，Port则保证在该badarg异常发生之前传送来自端口的退出信号。

port_command(Port, Data) -> true

类型

将数据发送到端口。与Port ! {PortOwner, {command, Data}}除了错误行为和同步（见下文）相同。任何进程都可以将数据发送到端口port_command/2，而不仅仅是端口所有者（连接的进程）。

比较：Port！ {PortOwner，{command，Data}}只会在badarg失败，如果端口没有引用端口或进程。 如果端口是封闭的端口，则数据消息在没有声音的情况下消失。 如果端口已打开且呼叫进程不是端口所有者，则端口所有者将因badsig而失败。 如果数据是无效的I / O列表，则端口所有者也会因badsig而失败。

请注意，任何进程都可以发送到端口Port ! {PortOwner, {command, Data}}，就好像它本身是端口所有者一样。

如果端口繁忙，则调用进程将被挂起，直到端口不再繁忙为止。

从Erlang / OTP R16开始，Port ! {PortOwner, {command, Data}}它确实是异步的。请注意，此操作始终被记录为异步操作，而底层实现已同步。但port_command/2由于其错误行为仍然完全同步。

失败：

badarg

如果Port不是开放端口的标识符，也不是开放端口的注册名称。如果调用进程以前已链接到关闭端口，则由Port，从端口发出的出口信号保证在此之前传递。badarg异常发生。

badarg

如果Data是无效的I/O列表。

port_command(Port, Data, OptionList) -> boolean()

类型

将数据发送到端口。port_command(Port, Data, [])等于port_command(Port, Data)。

如果端口命令被中止，则返回false，否则返回true。

如果端口繁忙，则调用进程将暂停，直到端口不再繁忙为止。

Options：

force如果端口繁忙，则调用进程不会挂起，而是强制端口命令通过。notsup如果端口的驱动程序不支持该调用，则调用将失败并产生异常。有关更多信息，请参阅driver标志![CDATA[ERL_DRV_FLAG_SOFT_BUSY]]。

nosuspend如果端口繁忙，调用进程不会挂起，而是端口命令被中止并false返回。

注

在未来的版本中可以添加更多的选项。

失败：

badarg 如果Port不是开放端口的标识符或开放端口的注册名称。如果调用进程先前已链接到由端口标识的封闭端口，Port则保证在该badarg异常发生之前传送来自端口的退出信号。 badarg 如果Data是无效的I / O列表。

badarg 如果OptionList是无效的选项列表。

notsup 如果选项force已通过，但该端口的驱动程序不允许强制通过繁忙的端口。

port_connect(Port, Pid) -> true

类型

将端口所有者（连接的端口）设置为Pid。同于Port ! {Owner, {connect, Pid}}除了以下内容：

• 错误行为不同，见下文。

• 该端口不回复{Port，connected}。

• port_connect/1是同步的，参见下面。

• 新的端口所有者被链接到端口。

旧端口所有者保持与端口的链接，必须调用unlink(Port)如果这是不想要的。任何进程都可以将端口所有者设置为port_connect/2...

比较：Port！ {self（），{connect，Pid}}只会在badarg失败，如果Port没有引用端口或进程。 如果Port是一个封闭的端口，则什么也不会发生 如果端口是开放端口并且呼叫进程是端口所有者，则端口将以{端口，已连接}回复到旧端口所有者。 请注意，旧的端口所有者仍然与端口相关联，而新的端口不是。 如果端口是开放端口，并且调用进程不是端口所有者，则端口所有者将因badsig而失败。 如果Pid不是现有的本地进程标识符，那么端口所有者也会因badsig而失败。

请注意，任何进程都可以将端口所有者设置为使用Port ! {PortOwner, {connect, Pid}}，就好像它本身是端口所有者一样，但答复总是发送给端口所有者。

来自Erlang/OTP R16，Port ! {PortOwner, {connect, Pid}}是真正异步的。注意，这个操作一直被记录为异步操作，而底层实现是同步的。但是port_connect/2由于其错误行为，仍然完全同步。

失败：

badarg如果Port不是开放端口的标识符，也不是开放端口的注册名称。如果调用进程以前已链接到关闭端口，则由Port，从端口发出的出口信号保证在此之前传递。badarg异常发生。badarg如果由Pid不是一个现有的本地进程。

port_control(Port, Operation, Data) -> iodata() | binary()

类型

在端口上执行同步控制操作。意义Operation和Data取决于端口，也就是端口驱动程序。并非所有端口驱动程序都支持此控制功能。

根据端口驱动程序的不同，返回范围为0..255或二进制的整数列表。返回数据的含义也取决于端口驱动程序。

失败：

badarg 如果Port不是开放端口或开放端口的注册名称。 badarg 如果Operation不能放入一个32位整数。

badarg 如果端口驱动程序不支持同步控制操作。

badarg 如果端口驱动程序因此而作出任何决定（可能是Operationor的错误Data）。

erlang:port_info(Port) -> Result

类型

返回包含带有关于信息的元组的列表Port，或者undefined端口未打开。元组的顺序是未定义的，所有的元组都不是强制的。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/1返回之前传送来自端口的出口信号undefined。

结果包含以下信息Items：

• registered_name （如果端口有注册名称）

• id

• connected

• links

• name

• input

• output

有关不同Items的更多信息，请参阅port_info/2。

失败：badarg如果Port不是本地端口标识符或原子。

erlang:port_info(Port, Item :: connected) ->

{connected, Pid} | undefined

类型

Pid连接到端口的进程的进程标识符。

如果标识的端口Port未打开，undefined则返回。如果端口关闭且呼叫过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符或原子。

erlang:port_info(Port, Item :: id) -> {id, Index} | undefined

类型

Index端口的内部索引。此索引可用于分隔端口。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符，也不是原子。

erlang:port_info(Port, Item :: input) ->

{Input，Bytes}未定义

类型

Bytes从端口读取的字节总数。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符或原子。

erlang:port_info(Port, Item :: links) -> {links, Pids} | undefined

类型

Pids链接到的进程的进程标识符的列表。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符，也不是原子。

erlang:port_info(Port, Item :: locking) ->

{locking, Locking} | undefined

类型

Locking为下列之一：

• false （没有SMP支持的模拟器）

• port_level （端口专用锁定）

• driver_level （驱动专用锁定）

请注意，这些结果是高度特定于实现的，并且可能在以后的版本中更改。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符，也不是原子。

erlang:port_info(Port, Item :: memory) ->

{memory, Bytes} | undefined

类型

Bytes是运行时系统为此端口分配的总字节数。端口本身可以分配未包含的内存Bytes。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符或原子。

erlang:port_info(Port, Item :: monitors) ->

{monitors, Monitors} | undefined

类型

Monitors表示由此端口监视的进程。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符或原子。

erlang:port_info(Port, Item :: monitored_by) ->

{monitored_by, MonitoredBy} | undefined

类型

当前监视给定端口的PIDS返回列表。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符，也不是原子。

erlang:port_info(Port, Item :: name) -> {name, Name} | undefined

类型

Name是由open_port/2设置的命令名称。

如果Port标识的端口未打开，则返回undefined。 如果端口关闭且调用进程先前已链接到端口，则保证port端口的退出信号在port_info / 2返回未定义之前发送。

失败：badarg如果Port不是本地端口标识符或原子。

erlang:port_info(Port, Item :: os_pid) ->

{os_pid, OsPid} | undefined

类型

OsPid是用来创建的OS进程的进程标识符（或等同者）open_port({spawn | spawn_executable, Command}, Options)。如果端口不是产生OS进程的结果，则值为undefined。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符或原子。

erlang:port_info(Port, Item :: output) ->

{Output，Bytes}未定义

类型

Bytes是使用从Erlang进程写入端口的总字节数port_command/2，port_command/3或Port ! {Owner, {command, Data}。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符，也不是原子。

erlang:port_info(Port, Item :: parallelism) ->

{parallelism, Boolean} | undefined

类型

Boolean对应于此端口使用的端口并行性提示。欲了解更多信息，请参见选项parallelism的open_port/2。

erlang:port_info(Port, Item :: queue_size) ->

{queue_size, Bytes} | undefined

类型

Bytes使用ERTS驱动程序队列实现的端口排队的字节总数。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符或原子。

erlang:port_info(Port, Item :: registered_name) ->

{registered_name, RegisteredName} |

[]

undefined

类型

RegisteredName是端口的注册名称。如果端口没有注册名称，[]则被返回。

如果标识的端口Port未打开，undefined则被返回。如果端口关闭且调用过程先前已链接到端口，则将保证在port_info/2返回之前传送来自端口的出口信号undefined。

失败：badarg如果Port不是本地端口标识符或原子。

port_to_list(Port) -> string()

类型

返回与端口标识符的文本表示相对应的字符串Port。

erlang:ports() -> port()

返回与本地节点上的所有端口对应的端口标识符列表。

请注意，存在退出端口，但未打开。

pre_loaded() -> module()

返回在系统中预加载的Erlang模块列表。由于所有代码的加载都是通过文件系统完成的，因此文件系统必须先前已加载。因此，至少该模块init必须预加载。

erlang:process_display(Pid, Type) -> true

类型

Pid在标准错误中写入关于本地进程的信息。atom唯一允许的值Type是backtrace，它显示了调用堆栈的内容，包括关于调用链的信息，并且首先打印当前函数。输出的格式没有进一步定义。

process_flag(Flag :: trap_exit, Boolean) -> OldBoolean

类型

当trap_exit设置为true，到达进程的退出信号被转换为{'EXIT', From, Reason}可作为普通消息接收的消息。如果trap_exit设置为false，则进程退出，如果它接收到非出口信号normal并且出口信号传播到其链接的进程。应用程序通常不会陷入退出。

返回标志的旧值。

另见exit/2...

process_flag(Flag :: error_handler, Module) -> OldModule

类型

用于为未定义函数调用和未定义注册进程重新定义错误处理程序的进程。没有经验的用户不使用此标志，因为代码自动加载取决于错误处理模块的正确操作。

返回标志的旧值。

process_flag(Flag :: min_heap_size, MinHeapSize) -> OldMinHeapSize

类型

更改调用进程的最小堆大小。

返回标志的旧值。

process_flag(Flag :: min_bin_vheap_size, MinBinVHeapSize) ->

OldMinBinVHeapSize

类型

更改调用进程的最小二进制虚拟堆大小。

返回标志的旧值。

process_flag(Flag :: max_heap_size, MaxHeapSize) -> OldMaxHeapSize

类型

此标志设置调用进程的最大堆大小。如果MaxHeapSize为整数，则系统默认值为kill和error_logger都是用的。

size

进程的最大字数。如果设置为零，则禁用堆大小限制。badarg如果值小于min_heap_size只有在触发垃圾收集时才会进行大小检查。

size触发垃圾回收时的整个进程堆。这包括所有分代堆、进程堆栈、任何messages that are considered to be part of the heap，以及垃圾收集器在收集过程中需要的任何额外内存。

size与可以使用erlang:process_info(Pid, total_heap_size)，或者通过添加heap_block_size，，，old_heap_block_size和mbuf_size从erlang:process_info(Pid, garbage_collection_info)...

kill

当设置为true，运行时系统发送不可捕获的退出信号。kill如果达到最大堆大小，则为进程。触发kill未完成，而是进程将尽快退出。当设置为false，没有向进程发送退出信号，而是继续执行。

如果kill未在地图中定义，则将使用系统默认值。默认的系统默认是true。它可以通过选项来改变+hmaxk的erl(1)，或erlang:system_flag(max_heap_size, MaxHeapSize)。

error_logger

当设置为true，运行时系统将消息发送给当前的error_logger包含有关达到最大堆大小时的进程的详细信息。一error_logger每次达到限制时都会发送报告。

如果error_logger未在地图中定义，则使用系统默认值。默认的系统默认是true。它可以通过选项+hmaxelint erl(1)或者更改erlang:system_flag(max_heap_size, MaxHeapSize)。

进程的堆大小很难预测，特别是垃圾回收期间使用的内存量。在考虑使用此选项时，建议首先在生产中使用kill设为false并检查error_logger报告，以查看系统中进程的正常峰值大小，然后相应地调整值。

process_flag(Flag :: message_queue_data, MQD) -> OldMQD

类型

此标志确定消息队列中消息的存储方式，如下所示：

off_heap

消息队列中的所有消息都将存储在进程堆外部。这意味着，没有在消息队列中的消息将是处理的垃圾收集的一部分。

on_heap

消息队列中的所有消息最终都将放在堆中。但是，它们可以暂时存储在堆之外。这就是在ERTS 8.0之前一直存储消息的方式。

默认message_queue_data进程标志由+hmqdin 命令行参数确定erl(1)。

如果该进程可能会收到很多消息，建议您将该标志设置为off_heap。 这是因为在堆上放置了许多消息的垃圾收集可能变得非常昂贵，并且该过程可能会消耗大量内存。 然而，当不使用标志off_heap时，实际消息传递的性能通常更好。

更改此标志时，消息将被移动。此工作已经启动，但在此函数调用返回时尚未完成。

返回标志的旧值。

process_flag(Flag :: priority, Level) -> OldLevel

类型

设置进程优先级。Level是一个原子。四个优先级有：low，normal，high，和max。默认是normal。

注

优先级别max保留给Erlang运行时系统中的内部使用，并且不供他人使用。

在每个优先级级别内部，进程以循环方式调度。

对优先级执行进程normal与low进行交错。优先进程low选择的执行次数低于进程优先级normal。

当存在优先级高的可运行进程时，不会选择优先级低或正常的进程执行。 但是请注意，这并不意味着当进程处于优先级较高的状态时，优先级较低或正常的进程无法运行。 在支持SMP的运行时系统上，与优先级高的进程相比，可以并行运行更多进程。 也就是说，可以同时执行低优先级进程和高优先级进程。

当存在优先级max的可运行进程时，不会选择优先级低，正常或高的进程执行。 与优先级高一样，较低优先级的进程可以与优先级最大的进程并行执行。

日程安排是先发制人的。不管优先级如何，当流程自上次被选择执行以来已经消耗了超过一定数量的减少时，它就会被抢占。

注

不要依赖于日程安排来保持今天的状态。至少在支持SMP的运行时系统上，调度可能会在将来的版本中更改，以便更好地使用可用的处理器核心。

有没有用于避免优先级反转，如优先级继承或优先天花板自动机构。在使用优先级时，请考虑并自行处理这些场景。

将来自高优先级进程的调用转换为您无法控制的代码可能会导致高优先级进程等待优先级较低的进程。 也就是说，在通话过程中有效地降低高优先级进程的优先级。 即使这种情况不适用于您无法控制的一个版本的代码，未来的版本也可能会出现这种情况。 例如，如果高优先级进程触发代码加载，则代码服务器按正常优先级运行。

normal通常不需要的其他优先事项。当使用其他优先事项时，请小心使用它们，尤其是优先事项high。优先级的过程high只是短时间执行工作。high由于重要的OTP服务器优先运行，因此在优先级过程中长时间忙于循环会导致最可能出现的问题normal。

返回标志的旧值。

process_flag(Flag :: save_calls, N) -> OldN

类型

N必须是0到10000之间的整数。 如果N> 0，则呼叫保存被激活用于该过程。 这意味着有关最近进行的N次全局函数调用，BIF调用，发送和接收的信息将保存在列表中，该列表可以使用process_info（Pid，last_calls）进行检索。 全局函数调用是明确提到函数的模块的函数。 只保存一定量的信息，如下所示：

• 元组{Module, Function, Arity}用于函数调用

• 原子send，'receive'并且timeout用于发送和接收（'receive'当接收到消息并且timeout当接收超时时）

如果N=0，将禁用进程的调用保存，这是默认的。每当设置调用保存列表的大小时，就会重置其内容。

返回标志的旧值。

process_flag(Flag :: sensitive, Boolean) -> OldBoolean

类型

设置或清除sensitive当前进程的标志。当某个进程被调用标记为敏感process_flag(sensitive, true)时，运行系统中用于检查数据或进程内部工作的功能将被静默禁用。

禁用的功能包括（但不限于）以下功能：

• 跟踪。仍然可以为进程设置跟踪标志，但不会生成任何类型的跟踪消息。（如果标志sensitive关闭，如果设置了任何跟踪标志，则会再次生成跟踪消息。）

• 顺序追踪。顺序跟踪令牌将像往常一样传播，但不会生成顺序跟踪消息。

process_info/1,2 不能用于读出消息队列或进程字典（两者都作为空列表返回）。

无法显示进程的堆栈回退跟踪。

在崩溃转储中，堆栈，消息和进程字典被省略。

如果{save_calls,N}已设置该过程，则不会将功能呼叫保存到呼叫保存列表。（呼叫保存列表未被清除，并且发送，接收和超时事件仍然添加到列表中。）

返回标志的旧值。

process_flag（Pid，Flag，Value） - > OldValue

类型

以与process_flag / 2相同的方式为进程Pid设置某些标志。 返回标志的旧值。 Flag的有效值只是process_flag / 2中允许的值的一个子集，即save_calls。

失败：badarg如果Pid不是本地进程。

process_info(Pid) -> Info

类型

返回包含InfoTuples 的列表，其中包含有关由进程标识的进程的其他信息Pid，或undefined进程是否处于活动状态。

InfoTuples的顺序是未定义的，并且所有InfoTuples不是必需的。 结果中的InfoTuples部分可以在没有事先通知的情况下进行更改。

InfoTuple具有以下项目的s是结果的一部分：

• current_function

• current_function

• status

• message_queue_len

• messages

• links

• dictionary

• trap_exit

• error_handler

• priority

• group_leader

• total_heap_size

• heap_size

• stack_size

• reductions

• garbage_collection

如果标识的过程Pid具有注册名称，则也包括一个InfoTuple与项目registered_name。

有关具体InfoTuples的信息，请参阅process_info/2。

警告

此BIF仅用于调试。为了所有其他目的，请使用process_info/2。

失败：badarg如果Pid不是本地进程。

process_info(Pid, Item) -> InfoTuple | [] | undefined

process_info(Pid, ItemList) -> InfoTupleList | [] | undefined

类型

返回Pid由Item或者指定的过程的信息ItemList。如果进程不存在，则返回undefined。

如果进程处于活动状态且指定了单个项目，则返回的值是相应的InfoTuple，除非Item =：= registered_name且进程没有注册名称。 在这种情况下，返回[]。 这种奇怪的行为是出于历史原因，并保持向后兼容。

如果ItemList被指定，结果是InfoTupleList。所述InfoTuple以s InfoTupleList都包括与相应的Item以相同的顺序作为S Item小号被列入ItemList。有效的Items可以包含多次ItemList。

注意

如果registered_name是ItemList的一部分，并且该过程没有注册名称，则{InfoName}，[InfoType]，InfoTuple将包含在生成的InfoTupleList中。 当指定单个Item =：= registered_name并使用process_info / 1时，此行为不同。

有效InfoTuples与相应的Items：

{backtrace, Bin}

二进制Bin包含与输出相同的信息erlang:process_display(Pid, backtrace)。用于binary_to_list/1从二进制文件中获取字符串。

{binary, BinInfo}

BinInfo是一个列表，其中包含有关此进程当前引用的二进制文件的各种信息。这InfoTuple可以在未事先通知的情况下更改或删除。在当前的实现中BinInfo是一个元组列表。元组包含; BinaryId，BinarySize，BinaryRefcCount。

{catchlevel, CatchLevel}

CatchLevel是此进程中当前活动捕获的数量。这InfoTuple可以在未事先通知的情况下更改或删除。

{current_function, {Module, Function, Arity}}

Module，Function，Arity是进程的当前函数调用。

{current_location, {Module, Function, Arity, Location}}

Module，Function，Arity是进程的当前函数调用。Location是描述源代码中位置的二元组列表。

{current_stacktrace, Stack}

返回进程的当前调用堆栈回溯（stacktrace）。该堆栈与返回的格式相同erlang:get_stacktrace/0。根据backtrace_depth系统标志设置，堆栈跟踪的深度被截断。

{dictionary, Dictionary}

Dictionary 是过程字典。

{error_handler, Module}

Module 是进程使用的错误处理程序模块（例如，对于未定义的函数调用）。

{garbage_collection, GCInfo}

GCInfo是一个列表，其中包含有关此进程的垃圾回收的各种信息。内容GCInfo可以更改，恕不另行通知。

{garbage_collection_info, GCInfo}

GCInfo是一个列表，其中包含有关此进程垃圾回收的详细信息。 GCInfo的内容如有更改，恕不另行通知。 有关每个项目的含义的详细信息，请参阅erlang：trace / 3中的gc_minor_start。

{group_leader, GroupLeader}

GroupLeader 是该流程I / O的组长。

{heap_size, Size}

Size是过程中最年轻的堆代的大小。这一代包括进程堆栈。这些信息是高度依赖于实施的，并且如果实施方式发生变化则可能会发生变化

{initial_call, {Module, Function, Arity}}

Module，Function，Arity是初始函数调用与该过程产生了。

{links, PidsAndPorts}

PidsAndPorts 是进程标识符和端口标识符的列表，其中进程具有链接的进程或端口。

{last_calls, false|Calls}

该值是false如果调用保存对于流程不活跃（请参阅process_flag/3）。如果调用保存处于活动状态，则返回一个列表，其中最后一个元素是最近调用的。

{memory, Size}

Size是进程的大小（以字节为单位）。这包括调用堆栈，堆和内部结构。

{message_queue_len, MessageQueueLen}

MessageQueueLen是当前进程在消息队列中的消息数量。这是MessageQueue作为信息项返回列表的长度messages（见下文）。

{messages, MessageQueue}

MessageQueue 是进程中的消息列表，尚未处理。

{min_heap_size, MinHeapSize}

MinHeapSize 是进程的最小堆大小。

{min_bin_vheap_size, MinBinVHeapSize}

MinBinVHeapSize 是进程的最小二进制虚拟堆大小。

{monitored_by, Pids}

进程标识符列表监视进程（带monitor/2）。

{monitors, Monitors}

监控程序列表（由其启动monitor/2），用于该进程。对于本地进程监视器或进程标识符的远程进程监视器，列表包括：

{process，Pid}进程由pid监视。 {process，{RegName，Node}}本地或远程进程按名称进行监控。 {port，PortId}本地端口由端口ID监控。 {端口，{RegName，节点}}本地端口受名称监控。 请注意，远程端口监视器不受支持，因此Node始终是本地节点名称。 {message_queue_data，MQD}

返回进程标志的当前状态message_queue_data。MQD是off_heap或者on_heap。有关更多信息，请参阅文档process_flag(message_queue_data, MQD)。

{priority, Level}

Level是该流程的当前优先级别。有关优先级的更多信息，请参阅process_flag(priority, Level)。

{reductions, Number}

Number 是过程执行的减少数量。

{registered_name, Atom}

Atom是注册的进程名称。如果进程没有注册名称，则此元组不在列表中。

{sequential_trace_token, [] | SequentialTraceToken}

SequentialTraceToken是该进程的顺序跟踪令牌。这InfoTuple可以在未事先通知的情况下更改或删除。

{stack_size, Size}

Size 是流程的堆栈大小。

{status, Status}

Status 是过程的状态并且是以下之一：

• exiting

• garbage_collecting

• waiting （用于消息）

• running

• runnable （准备运行，但另一个进程正在运行）

• suspended（暂停在“繁忙”端口或BIF erlang:suspend_process/1,2）

{suspending, SuspendeeList}

SuspendeeList是{Suspendee，ActiveSuspendCount，OutstandingSuspendCount}元组的列表。 Suspendee是Pid通过BIF erlang：suspend_process / 2或erlang：suspend_process / 1标识的进程已经或将要暂停的进程的进程标识符。

ActiveSuspendCount是Pid暂停Suspendee的次数。 OutstandingSuspendCount是由Pid发送的尚未完成的挂起请求的数量，即：

• 如果ActiveSuspendCount = / = 0，则Suspendee当前处于挂起状态。

如果OutstandingSuspendCount = / = 0，则使用erlang：suspend_process / 2的异步选项，并且尚未暂挂Pid。

请注意，ActiveSuspendCount而OutstandingSuspendCount不是总暂停指望Suspendee，只贡献的部分Pid。

{total_heap_size, Size}

Size是整个过程的所有堆碎片的总大小。这包括进程栈和任何被认为是堆的一部分的未被接收的消息。

{trace, InternalTraceFlags}

InternalTraceFlags是表示此进程的内部跟踪标志的整数。这InfoTuple可以在未事先通知的情况下更改或删除。

{trap_exit, Boolean}

如果进程陷入退出，布尔值为true，否则为false。

注意并不是所有的实现都支持所有这些Item。

失败：

badarg如果Pid不是本地进程。 badarg如果项目是无效的项目。

processes（） - > pid（）

返回与本地节点上当前存在的所有进程相对应的进程标识符列表。

请注意，退出过程存在，但不存在。也就是说，退出进程的is_process_alive/1返回值false，但其进程标识符是返回结果的一部分processes/0。

例：

> processes().
[<0.0.0>,<0.2.0>,<0.4.0>,<0.5.0>,<0.7.0>,<0.8.0>]

purge_module（模块） - > true

类型

删除模块的旧代码。 在使用此BIF之前，将调用check_process_code / 2来检查没有进程在模块中执行旧代码。

警告

这个BIF用于代码服务器（见code(3)），不用于其他地方。

注意

从ERTS 8.0（Erlang / OTP 19）开始，仍然执行旧代码的任何延迟进程都会被该函数终止。在早期版本中，这种不正确的使用可能会导致更多致命的故障，如仿真器崩溃。

失败：badarg如果没有旧代码Module。

put(Key, Val) -> term()

类型

将一个新的Key添加到与Val值关联的流程字典中，并返回undefined。 如果Key存在，则旧值将被删除并由Val替换，并且该函数返回旧值。 例：

> X = put(name, walrus), Y = put(name, carpenter),
Z = get(name),
{X, Y, Z}.
{undefined,walrus,carpenter}

注意

当put被存储的值在catch的范围内计算时，如果throw被评估，或者发生错误，则不会收回。

erlang:raise(Class, Reason, Stacktrace) -> no_return()

类型

停止调用进程的与指定类，因此，和调用栈回溯（的一个异常的执行堆栈跟踪）。

Class是error，exit，或throw。所以，如果它不是用于堆栈跟踪的，erlang:raise(Class, Reason, Stacktrace)就相当于erlang:Class(Reason)。

Reason是任何术语。Stacktrace是一个返回的列表get_stacktrace()，即四元组列表{Module, Function, Arity | Args, Location}，其中Module和Function是原子，第三个元素是整数元素或参数列表。stacktrace也可以包含{Fun, Args, Location}元组，其中Fun是一个本地函数，并且Args是一个参数列表。

最后的元素Location是可选的。省略它相当于指定一个空列表。

堆栈跟踪用作调用进程的异常堆栈跟踪; 它被截断到当前的最大堆栈跟踪深度。

当评估这个函数导致进程终止时，除非参数无效，否则它没有返回值，在这种情况下函数返回错误原因 badarg。如果你想确保不返回，你可以调用error(erlang:raise(Class, Reason, Stacktrace))并希望以后区分例外情况。

erlang:read_timer(TimerRef) -> Result

类型

读取计时器的状态。同调用erlang:read_timer(TimerRef, [])。

erlang:read_timer(TimerRef, Options) -> Result | ok

类型

读取由erlang：start_timer或erlang：send_after创建的计时器的状态。 TimerRef标识定时器，并由创建定时器的BIF返回。

Options:

{async, Async}

异步请求状态信息。Async默认为false，这会导致操作同步执行。在这种情况下，Result返回erlang:read_timer。当Async是true，erlang:read_timer发送对所述状态信息到管理定时器，然后返回定时器服务的异步请求ok。该格式的消息将在操作处理完成后{read_timer, TimerRef, Result}发送给调用者erlang:read_timer。

Option将来可以添加更多的功能。

如果Result是false，对应于TimerRef找不到。这是因为计时器已过期，或已被取消，或因为TimerRef从来没有和计时器相对应。即使计时器已经过期，它也不会告诉您超时消息是否已到达其目的地。

如果Result是false，则TimerRef找不到对应的计时器。这是因为计时器已经过期，或已被取消，或者因为TimerRef从未与计时器相对应。即使计时器已过期，它也不会告诉您超时消息是否已到达目的地。

注意

管理定时器的定时器服务可以与调用进程正在执行的调度器之外的另一个调度器共处一处。如果是这样，与定时器服务的通信比在本地定位服务需要更长的时间。如果调用进程处于关键路径中，并且在等待此操作的结果时可以执行其他操作，则需要使用选项{async, true}。如果使用选项{async, false}，调用过程将被阻止，直到执行操作。

另见erlang:send_after/4，erlang:start_timer/4和erlang:cancel_timer/2。

ref_to_list(Ref) -> string()

类型

返回对应于文本表示的字符串Ref。

警告

该BIF仅用于调试，不适用于应用程序。

register(RegName, PidOrPort) -> true

类型

将该名称RegName与进程标识符（pid）或端口标识符关联。RegName必须是一个原子，可以用来代替发送操作符（RegName ! Message）中的pid或端口标识符。例：

> register(db, Pid).
true

失败：

badarg如果PidOrPort不是现有的本地进程或端口。 badarg如果RegName已被使用。 badarg如果进程或端口已经注册（已经有名字）。 badarg如果RegName是未定义的原子。

registered() -> RegName

类型

返回已使用的名称列表register/2，例如：

> registered().
[code_server, file_server, init, user, my_db]

erlang:resume_process(Suspendee) -> true

类型

减少由Suspendee标识的进程的暂停计数。Suspendee预先已通过悬浮erlang:suspend_process/2或erlang:suspend_process/1由过程调用erlang:resume_process(Suspendee)。当暂停计数Suspendee达到零时，恢复Suspendee，也就是说，其状态从暂停状态改变到它暂停之前的状态。

警告

此BIF仅用于调试。

失败：

badarg 如果Suspendee不是进程标识符。

badarg 如果过程调用erlang:resume_process/1之前没有增加由过程确定的过程的暂停计数Suspendee。

badarg 如果标识的过程Suspendee不存在。

round(Number) -> integer()

类型

通过四舍五入Number来返回整数，例如：

round(5.5).
6

允许在when模式匹配下使用

self（） - > pid（）

返回调用进程的进程标识符，例如：

> self（）。
<0.26.0>

允许在when模式匹配下使用

erlang：发送（Dest，Msg） - > Msg

类型

发送消息并返回Msg。这与Dest ! Msg相同

Dest可以是远程或本地进程标识符，（本地）端口，本地注册名称或{RegName, Node}另一个节点上注册名称的元组。

erlang:send(Dest, Msg, Options) -> Res

类型

要么发送消息并返回ok，要么不发送消息，而是返回其他消息（请参见下文）。否则类似于erlang:send/2。有关更详细的解释和警告，请参阅erlang:send_nosuspend/2,3。

选项：

nosuspend如果发件人不得不暂停发送，nosuspend则被返回。 noconnect 如果目标节点必须自动连接才能发送，noconnect则被返回。

警告

与erlang:send_nosuspend/2,3：极其谨慎地使用。

erlang:send_after(Time, Dest, Msg) -> TimerRef

类型

启动一个计时器。同erlang:send_after(Time,Dest,Msg, [])。

erlang:send_after(Time, Dest, Msg, Options) -> TimerRef

类型

启动一个计时器。当定时器到期时，消息Msg被发送到由标识的进程Dest。除了超时消息的格式之外，这个函数完全按照erlang:start_timer/4。

erlang:send_nosuspend(Dest, Msg) -> boolean()

类型

与erlang:send(Dest,Msg, [nosuspend])相同，但如果邮件已发送，并且邮件未发送则返回true，发件人必须被暂停则返回false

此函数旨在将操作发送到不可靠的远程节点，而不会阻塞发送（Erlang）进程。如果连接到远程节点（通常不是真正的Erlang节点，而是用C或Java编写的节点）被重载，则此函数不会发送消息并返回false。

如果Dest引用繁忙的本地端口，则会发生同样的情况。对于所有其他目的地（允许普通发送操作员'!'），该功能发送消息并返回true。

该功能仅用于极少数情况下，一个进程与Erlang节点进行通信，这些节点可能会在没有任何跟踪的情况下消失，导致TCP缓冲区和驱动程序队列在节点关闭之前过满（由于节拍超时）通过net_kernel。发生这种情况时要采取的正常反应是某种其他节点过早关闭。

注意忽略这个函数的返回值会导致不可靠的消息传递，这与Erlang编程模型相矛盾。如果此函数返回false，则不发送消息。

在许多系统中，过载队列的瞬时状态是正常的。虽然这个函数返回false并不意味着其他节点保证不响应，但它可能是一个临时过载。此外，返回值true只意味着消息可以在（TCP）通道上发送而不会阻塞; 该消息不保证到达远程节点。对于断开的非响应节点，返回值是true（模仿操作符的行为!）。预期的行为和函数返回时采取的操作false是应用程序和硬件特定的。

警告

谨慎使用。

erlang:send_nosuspend(Dest, Msg, Options) -> boolean()

类型

与erlang相同：send（Dest，Msg，[nosuspend | Options]），但是带有一个布尔返回值。

这个函数的行为类似于erlang:send_nosuspend/2第三个参数，即选项列表。唯一的选择是noconnect，如果远程节点当前无法到达本地节点，则会使该函数返回false。正常的行为是尝试连接到节点，这会在短时间内停止进程。使用选项noconnect可以确保发送到远程进程时不会有丝毫的延迟。当与期望永远是连接部分的节点（即用C或Java编写的节点）通信时，这是特别有用的。

每当函数返回false（无论是何时发生挂起或何时noconnect指定并且节点尚未连接），都会保证不发送该消息。

警告

谨慎使用。

erlang：set_cookie（Node，Cookie） - > true

类型

设置Node原子的magic Cookie。如果Node是本地节点，该函数还会将所有其他未知节点的cookie设置为Cookie（请参阅Distributed Erlang系统文档中的“Erlang参考手册” 一节）。

失败：function_clause 如果本地节点不存在。

setelement（Index，Tuple1，Value） - > Tuple2

类型

1..tuple_size（Tuple1

返回一个元组，该元组是Tuple1由整数参数指定的元素Index（第一个元素是索引为1的元素）被参数替换的参数的副本Value，例如：

> setelement(2, {10, green, bottles}, red).
{10,red,bottles}

size(Item) -> integer() >= 0

类型

返回元组中元素的数量或二进制或位串中的字节数，例如：

> size({morni, mulle, bwange}).
3
> size(<<11, 22, 33>>).
3

对于位串，返回整个字节的数量。即，如果位的位串的数量不能被8整除，所得到的字节数被舍入向下。

允许在when模式匹配下使用

另见tuple_size/1，byte_size/1和bit_size/1。

spawn（Fun） - > pid（）

类型

返回由应用程序启动Fun到空列表的新进程的进程标识符[]。否则，就如spawn/3。

spawn(Node, Fun) -> pid()

类型

将由Fun应用程序启动的新进程的进程标识符返回到Node上的空列表[]。 如果Node不存在，则返回无用的pid。 否则就像spawn / 3一样。

spawn（Module，Function，Args） - > pid（）

类型

返回的应用程序启动一个新的进程的进程标识符Module:Function来Args。

error_handler:undefined_function(Module, Function, Args)如果Module:Function/Arity不存在，则由新过程评估（其中Arity的长度Args）。错误处理程序可以重新定义（请参阅process_flag/2）。如果error_handler未定义，或者用户重新定义了默认值，error_handler并且其替换值未定义，undef则会发生原因失败。

例：

> spawn(speed, regulator, [high_speed, thin_cut]).
<0.13.1>

spawn（Node，Module，Function，Args） - > pid（）

类型

返回由模块：函数的应用程序启动的新进程的进程标识符（pid）以指向节点上的参数。 如果Node不存在，则返回无用的pid。 否则就像spawn / 3一样。

spawn_link（Fun） - > pid（）

类型

返回由应用程序启动Fun到空列表的新进程的进程标识符[]。在调用进程和新进程之间创建一个链接，以原子方式。否则，就如spawn/3。

spawn_link(Node, Fun) -> pid()

类型

返回的应用程序启动一个新的进程的进程标识（PID）Fun为空列表[]上Node。在调用进程和新进程之间创建一个链接，以原子方式。如果Node不存在，则返回一个无用的pid，并将具有原因的退出信号noconnection发送到调用进程。否则，工作就像spawn/3。

spawn_link(Module, Function, Args) -> pid()

类型

返回的应用程序启动一个新的进程的进程标识符Module:Function来Args。在调用进程和新进程之间创建一个链接，以原子方式。否则，就如spawn/3。

spawn_link(Node, Module, Function, Args) -> pid()

类型

返回的应用程序启动一个新进程的进程标识符（PID） Module:Function，以Args上的Node在调用进程和新进程之间创建一个链接，以原子方式。如果Node不存在，则返回一个无用的pid，并将具有原因的退出信号noconnection发送到调用进程。否则，就如spawn/3。

spawn_monitor(Fun) -> {pid(), reference()}

类型

返回新进程的进程标识符，由应用程序启动Fun到空列表[]以及为新进程创建的监视器的引用。否则，就如spawn/3。

spawn_monitor(Module, Function, Args) -> {pid(), reference()}

类型

一个新的进程是由应用程序启动Module:Function到Args。该过程同时进行监控。返回显示器的进程标识符和引用。否则，就如spawn/3。

spawn_opt(Fun, Options) -> pid() | {pid(), reference()}

类型

返回由应用程序启动Fun到空列表的新进程的进程标识符（pid）[]。否则，就如spawn_opt/4。

如果monitor指定了选项，则会监视新创建的进程，并返回监视器的pid和引用。

spawn_opt(Node, Fun, Options) -> pid() | {pid(), reference()}

类型

返回的应用程序启动一个新的进程的进程标识（PID）Fun为空列表[]上Node。如果Node不存在，则返回无用的pid。否则，就如spawn_opt/4。

pawn_opt(Module, Function, Args, Options) ->

pid（）| {pid（），reference（）}

类型

作为spawn/3，除了在创建过程时指定了额外的选项列表。

如果monitor指定了选项，则会监视新创建的进程，并返回监视器的pid和引用。

选项：

link

设置一个到父进程的链接（像spawn_link/3那样）。

monitor

监控新流程（就像monitor/2）。

{priority, Level

设置新进程的优先级。等同于process_flag(priority,Level)在新进程的启动功能中执行，除了优先级在第一次选择执行进程之前设置。有关优先级的更多信息，请参阅process_flag(priority,Level)。

{fullsweep_after, Number}

仅用于性能调整。除非您知道执行时间或内存消耗存在问题，并确保该选项可以改善问题，否则请勿使用此选项。

Erlang运行时系统使用分代垃圾收集方案，对至少存在一个垃圾收集的数据使用“旧堆”。当旧堆没有更多空间时，完成全部扫描垃圾收集。

选项fullsweep_after可以在强制全扫描之前指定最大世代收集数量，即使旧堆空间有限也是如此。将数字设置为零将禁用常规采集算法，即所有实时数据都将在每个垃圾收集处复制。

有些情况下可以更改fullsweep_after：

• 如果不再使用的二进制文件将被尽快抛弃。（设置Number为零。）

• 一个主要拥有短期数据的进程很少或永远不会完成，也就是说，旧堆大部分包含垃圾。为了确保偶尔会发生全面扫描，请设置Number为合适的值，例如10或20。

• 在RAM数量有限且没有虚拟内存的嵌入式系统中，您可能希望通过设置Number为零来保留内存。（该值可以在全局范围内设置，请参阅erlang:system_flag/2。）{min_heap_size, Size} 仅用于性能调整。除非您知道执行时间或内存消耗存在问题，并且确保该选项可以改善问题，否则请勿使用此选项。以字为单位给出最小堆大小。将此值设置为高于系统默认值可以加快某些进程，因为垃圾收集的次数较少。但是，设置太高的值可能会浪费内存并由于数据局部性更差而使系统变慢。因此，只能使用此选项来微调应用程序并使用各种Size值来测量执行时间。 {min_bin_vheap_size, VSize} 仅用于性能调整。除非您知道执行时间或内存消耗存在问题，并且确保该选项可以改善问题，否则请勿使用此选项。以字为单位提供最小的二进制虚拟堆大小。将此值设置为高于系统默认值可以加快某些进程，因为垃圾收集的次数较少。但是，设置太高的值可能会浪费内存。因此，只能使用此选项来微调应用程序并使用各种VSize值来测量执行时间。 {max_heap_size, Size} 设置max_heap_size进程标志。默认max_heap_size由命令行参数来确定+hmax在erl(1)。有关更多信息，请参阅文档process_flag(max_heap_size,Size)。 {message_queue_data, MQD} 设置message_queue_data进程标志的状态。MQD应该是off_heap或者on_heap。默认message_queue_data进程标志由+hmqdin 命令行参数确定erl(1)。有关更多信息，请参阅process_flag(message_queue_data,MQD).spawn_opt（节点，模块，函数，参数，选项） - > pid（）| 的文档。{PID（），参考（）} TypesReturns通过应用开始了新的进程的进程标识符（PID） Module:Function，以Args上Node。如果Node不存在，则返回无用的pid。否则工作方式类似于spawn_opt/4.NoteTable monitor不受支持spawn_opt/5。.split_binary（Bin，Pos） - > {binary（），binary（）} Types0..byte_size（Bin）返回包含二进制文件的元组，该二进制文件Bin分为两部分位置Pos。这不是一个破坏性的操作。手术后，共有三个二进制文件。例如：> B = list_to_binary（“0123456789”）。<<“0123456789”>>> byte_size（B）。10> {B1，B2} = split_binary（B，3）。{<<“012”>>，<<“3456789”>>}> byte_size（B1）。3> byte_size（B2）。7erlang：start_timer（Time，Dest，Msg） - > TimerRefTypesStart一个计时器。与调用erlang:start_timer(Time,Dest,Msg, []).erlang 相同：start_timer（Time，Dest，Msg，Options） - > TimerRefTypesStart一个计时器。当定时器到期时，消息{timeout, TimerRef, Msg}被发送到由标识的进程Dest。Options： {abs, false} 这是默认值。这意味着该Time值被解释为以毫秒为单位的相对当前时间Erlang monotonic time。 {abs, true} 绝对值Time。该Time值被解释为以毫秒为单位Option的绝对Erlang单调时间。将来可以添加更多的s。绝对时间点，定时器设置为过期时间，必须在间隔内[erlang:system_info(start_time),erlang:system_info(end_time)]。如果指定了相对时间，Time则不允许为负值。如果Dest是a pid()，则它必须是pid()在当前运行时系统实例上创建的进程中的一个。这个过程已经结束或者没有结束。如果Dest是atom()，则它被解释为本地注册过程的名称。定时器到期时查询该名称所涉及的过程。如果名称不指向进程，则不返回错误。如果Dest是a pid()，则定时器将自动取消，如果进程所引用的进程pid()没有活着，或者流程退出。此功能是在ERTS 5.4.11中引入的。请注意，定时器不会自动取消，当Dest是。atom()另请参阅erlang:send_after/4。erlang:cancel_timer/2，和。erlang:read_timer/2失败：badarg如果参数不满足此处指定的要求，统计信息（Item :: active_tasks） - > ActiveTasksTypes返回与之相同的值statistics(active_tasks_all)除了没有关于脏IO运行队列及其关联调度程序的信息是结果的一部分。也就是说，只有预期会受CPU限制的任务才是result.statistics（Item :: active_tasks_all）的一部分 - > ActiveTasksTypes返回一个列表，其中每个元素表示每个运行队列及其关联调度程序上活动进程和端口的数量。也就是说，准备运行或正在运行的进程和端口的数量。正常运行队列及其相关调度程序的值首先位于结果列表中。第一个元素对应于调度器编号1等等。如果存在对脏调度程序的支持，一个具有脏CPU运行队列值及其相关的脏CPU调度器值的元素，然后作为脏IO运行队列及其关联的脏IO调度器的值跟随的最后一个元素。信息是没有原子聚集。也就是说，结果不一定是状态的一致快照，而是相当高效地收集。注意每个普通调度程序都有一个它管理的运行队列。如果支持脏调度程序调度程序，则所有脏CPU调度程序共享一个运行队列，并且所有脏IO调度程序共享一个运行队列。也就是说，我们有多个正常运行队列，一个脏CPU运行队列和一个脏IO运行队列。工作不能在不同类型的运行队列之间迁移。只有在正常运行队列中工作才能迁移到其他正常运行队列。这也评估result.See时要考虑到statistics(total_active_tasks)，statistics(run_queue_lengths)，statistics(run_queue_lengths_all)，statistics(total_run_queue_lengths)，和statistics(total_run_queue_lengths_all)。统计（项目:: context_switches） - > {ContextSwitches，0} TypesReturns上下文切换的总数，因为系统started.statistics（项目:: exact_reductions） - > {Total_Exact_Reductions，Exact_Reductions_Since_Last_Call} TypesReturns确切reductions.Note的数目statistics(exact_reductions)是一个比statistics(reductions)SMP支持的Erlang机器更昂贵的操作.statistics（Item :: garbage_collection） - > {Number_of_GCs，Words_Reclaimed，0} TypesReturns有关垃圾回收的信息，例如：> statistics（garbage_collection）。{85,23961,0}这些信息可能对某些实现无效。统计信息（Item :: io） - > {{input，Input}，{output，Output}} TypesReturns Input，通过端口接收的总字节数，和Output，这是输出到ports.statistics（Item :: microstate_accounting）的总字节数 - > MSAcc_Thread | undefinedTypesMicrostate会计可用于测量Erlang运行时系统花费多少时间完成各种任务。它被设计成尽可能轻量级，但是当启用时存在一些开销。Microstate会计旨在成为帮助查找性能瓶颈的分析工具。要start/ stop/ reset微观统计，使用系统标志microstate_accounting。statistics(microstate_accounting)返回表示ERTS中某些OS线程的映射列表。每个地图包含type和id可用于标识它是什么线程的字段，以及包含有关在各种状态下花费了多少时间的数据的计数器字段。示例：> erlang：statistics（microstate_accounting）。[＃{counters =>＃{aux => 1899182914，check_io => 2605863602，emulator => 45731880463，gc => 1512206910，other => 5421338456，port => 221631，sleep => 5150294100}，id => 1，type => scheduler} | ...]时间单位与返回的时间单位相同os:perf_counter/0。因此，要将其转换为毫秒，您可以执行下列操作：列表：map（fun（＃{counters：= Cnt} = M） - > MsCnt = maps：map（fun（_K，PerfCount） - > erlang：convert_time_unit （PerfCount，perf_counter，1000）end，Cnt），M＃{counters：= MsCnt} end，erlang：statistics（microstate_accounting））注意，这些值不能保证在每个状态下花费的确切时间。这是因为进行了各种优化以尽可能降低开销。MSAcc_Thread_Types： scheduler执行大部分工作的主要执行线程。dirty_cpu_scheduler长时间运行cpu密集型工作的线程。dirty_io_scheduler长时间运行I / O工作的线程。async各种链接驱动程序（主要是文件驱动程序）使用异步线程卸载非CPU密集型工作。aux负责任何未明确分配给调度人员的工作。以下MSAcc_Thread_State是可用的。所有状态都是独占的，这意味着一个线程不能一次处于两种状态。所以，如果你添加一个线程中的所有计数器的数量，你会得到该线程的总运行时间。 aux花时间处理辅助工作。check_io花在检查新I / O事件上的时间。emulator花费在执行Erlang进程上的时间。gc花时间做垃圾回收。当启用额外状态时，这是花在做非全扫描垃圾收集上的时间。other花时间做下落不明的事情。port花时间执行端口。sleep花时间睡觉。MSAcc_Thread_State可以通过配置（如./configure --with-microstate-accounting=extra）添加更多细粒度的s 。如果关闭微状态计费，启用这些状态会导致性能下降，并在打开状态时增加开销。 alloc花时间管理内存。这次没有额外的国家分散在所有其他国家。bif花在BIF上的时间。没有额外的国家这次是emulator国家的一部分。busy_wait时间花在忙等待。这也是调度程序在使用时不再报告它处于活动状态的状态statistics(scheduler_wall_time)。所以，如果你添加所有其他状态而不是睡眠，然后在线程中一直划分它，你应该得到与scheduler_wall_time分数非常相似的东西。没有额外的国家这次是other国家的一部分。ets花在执行ETS BIF上的时间。没有额外的国家这次是emulator国家的一部分。gc_full花时间做完整扫描垃圾收集。没有额外的国家这次是gc国家的一部分。nif花在NIF上的时间。没有额外的国家这次是emulator国家的一部分。send花时间发送消息（仅限进程）。没有额外的国家这次是emulator国家的一部分。timers花时间管理定时器。没有额外的国家这次是other国家的一部分。该实用程序模块msacc(3)可用于更轻松地分析这些统计信息。undefined如果系统标记则返回microstate_accounting已关闭。线程信息列表未排序，可能以不同顺序在调用之间出现。注意线程和状态可能会随时更改，而无需事先通知。统计信息（Item :: reduction） - > {Total_Reductions，Reductions_Since_Last_Call} TypesReturns减少，例如：>统计（减少）。{2046,11}注意从ERTS 5.5（Erlang / OTP R11B）中，该值不包括在当前调度的进程的当前时间片中执行的减少。如果需要确切的值，请使用statistics(exact_reductions).statistics（Item :: run_queue） - > integer（）> = 0返回所有正常运行队列的总长度。也就是说，准备在所有可用的正常运行队列上运行的进程和端口的数量。脏运行队列不是结果的一部分。信息是自动收集的。也就是说，结果是状态的一致快照，但是与statistics(total_run_queue_lengths)使用大量调度程序相比，此操作要昂贵得多.statistics（Item :: run_queue_lengths） - > RunQueueLengthTypes返回与statistics(run_queue_lengths_all)不同之处在于没有关于脏IO运行队列的信息是结果的一部分。也就是说，只有预期CPU限制的工作的运行队列是result.statistics（Item :: run_queue_lengths_all）的一部分 - > RunQueueLengthTypes返回一个列表，其中每个元素表示准备为每个运行队列运行的进程和端口的数量。正常运行队列的值首先位于结果列表中。第一个元素对应于调度程序编号1的正常运行队列，依此类推。如果存在对脏调度程序的支持，则最后使用脏CPU运行队列和脏IO运行队列的值（按该顺序）。信息不是原子聚集。也就是说，结果不一定是状态的一致快照，而是相当高效地收集。注意每个普通调度程序都有一个它管理的运行队列。如果支持脏调度程序调度程序，则所有脏CPU调度程序共享一个运行队列，并且所有脏IO调度程序共享一个运行队列。也就是说，我们有多个正常运行队列，一个脏CPU运行队列和一个脏IO运行队列。工作不能在不同类型的运行队列之间迁移。只有在正常运行队列中工作才能迁移到其他正常运行队列。这也评估result.See时要考虑到statistics(run_queue_lengths)，statistics(total_run_queue_lengths_all)，statistics(total_run_queue_lengths)，statistics(active_tasks)，statistics(active_tasks_all)，和statistics(total_active_tasks)，statistics(total_active_tasks_all).statistics（Item :: runtime） - > {Total_Run_Time，Time_Since_Last_Call}类型返回有关运行时的信息，以毫秒为单位。这是Erlang运行时系统中所有线程运行时间的总和，因此可以大于挂钟时间.WarningThis由于所使用的操作系统提供的底层功能的限制，值可能会打包。例如：> statistics（运行时）。{1690,1620} statistics（Item :: scheduler_wall_time） - > {SchedulerId，ActiveTime，TotalTime} | undefinedTypes返回具有以下元组的列表：{SchedulerId, ActiveTime, TotalTime}其中SchedulerId是调度程序的整数ID，ActiveTime是调度程序一直占用的持续时间，并且TotalTime是从scheduler_wall_time激活特定的调度程序。请注意，调度程序之间的激活时间可能显着不同。目前肮脏的调度程序在系统启动时被激活，而正常的调度程序在scheduler_wall_time功能被启用一段时间后被激活。时间单位未定义，可能会在版本，操作系统和系统重新启动之间发生变化。scheduler_wall_time仅用于计算调度程序使用率的相对值。ActiveTime不能超过TotalTime。繁忙调度程序的定义是当它不是空闲的时候，并且不调度（选择）一个过程或端口，即：

• 执行流程代码

• 执行链接的驱动程序或NIF代码

• 执行BIF或任何其他运行时处理

• 垃圾收集

• 处理任何其他内存管理

请注意，即使操作系统调度了调度程序线程，调度程序也可能很忙。

系统标志scheduler_wall_time关闭时返回undefined。

调度程序信息列表是未排序的，可以按不同的调用顺序显示。

从ERTS版本9.0开始，结果中也包含脏CPU调度程序。也就是说，所有预期处理CPU绑定工作的调度程序线程。如果您还需要有关脏I / O调度程序的信息，请statistics(scheduler_wall_time_all)改为使用。

正常调度程序将在该范围内具有调度程序标识符1 =< SchedulerId =<erlang:system_info(schedulers)。CPU调度程序将在该范围内具有调度程序标识符erlang:system_info(schedulers) < SchedulerId =< erlang:system_info(schedulers) +erlang:system_info(dirty_cpu_schedulers)。

注意

不同类型的调度程序处理特定类型的作业。每个作业都被分配到一个特定的调度程序类型。作业可以在相同类型的不同调度器之间迁移，但不能在不同类型的调度器之间迁移。在评估返回的结果时，必须考虑到这一事实。

使用scheduler_wall_time计算调度利用率：

> erlang:system_flag(scheduler_wall_time, true).
false
> Ts0 = lists:sort(erlang:statistics(scheduler_wall_time)), ok.
ok

过了一段时间，用户会获取另一个快照并计算每个调度程序的调度程序利用率，例如：

> Ts1 = lists:sort(erlang:statistics(scheduler_wall_time)), ok.
ok
> lists:map(fun({{I, A0, T0}, {I, A1, T1}}) -> {I, (A1 - A0)/(T1 - T0)} end, lists:zip(Ts0,Ts1)).
[{1,0.9743474730177548},
 {2,0.9744843782751444},
 {3,0.9995902361669045},
 {4,0.9738012596572161},
 {5,0.9717956667018103},
 {6,0.9739235846420741},
 {7,0.973237033077876},
 {8,0.9741297293248656}]

使用相同的快照计算总调度程序使用率：

> {A, T} = lists:foldl(fun({{_, A0, T0}, {_, A1, T1}}, {Ai,Ti}) -> {Ai + (A1 - A0), Ti + (T1 - T0)} end, {0, 0}, lists:zip(Ts0,Ts1)), TotalSchedulerUtilization = A/T.
0.9769136803764825

当所有调度程序在两次测量之间一直处于活动状态时，调度程序的总利用率将与1.0相等。

另一个（可能更多）有用的值是计算总计划程序利用率加权最大可用CPU时间量：

> WeightedSchedulerUtilization = (TotalSchedulerUtilization * (erlang:system_info(schedulers) + erlang:system_info(dirty_cpu_schedulers))) / erlang:system_info(logical_processors_available).
0.9769136803764825

当调度程序处于活动状态的时间与最大可用CPU时间相同时，此加权调度程序的使用率将达到1.0。如果存在比可用的逻辑处理器更多的调度器，则该值可能大于1.0。

从ERTS版本9.0开始，具有SMP支持的Erlang运行时系统默认具有比逻辑处理器更多的调度程序。这是由于脏的调度程序。

注意

scheduler_wall_time默认是禁用的。要启用它，请使用erlang:system_flag(scheduler_wall_time, true)。

statistics(Item :: scheduler_wall_time_all) ->

{SchedulerId, ActiveTime, TotalTime} | undefined

类型

statistics(scheduler_wall_time)与之相同，但它也包含有关所有脏I / O调度程序的信息。

IO调度程序将在该范围内具有调度程序标识符erlang:system_info(schedulers)+erlang:system_info(dirty_cpu_schedulers)< SchedulerId =< erlang:system_info(schedulers) + erlang:system_info(dirty_cpu_schedulers) +erlang:system_info(dirty_io_schedulers)。

注意

请注意，在I / O调度程序上执行的工作预计将主要等待I / O。也就是说，当你在I / O调度，在CPU利用率高利用率调度不有望再创新高，这是因为这项工作。

statistics(Item :: total_active_tasks) -> ActiveTasks

类型

就如调用lists:sum(statistics(active_tasks))，但效率更高。

statistics(Item :: total_active_tasks_all) -> ActiveTasks

类型

就如调用lists:sum(statistics(active_tasks_all))，但效率更高。

statistics(Item :: total_run_queue_lengths) ->

TotalRunQueueLengths

类型

就如调用lists:sum(statistics(run_queue_lengths))，但效率更高。

statistics(Item :: total_run_queue_lengths_all) ->

TotalRunQueueLengths

类型

就如调用lists:sum(statistics(run_queue_lengths_all))，但效率更高。

statistics(Item :: wall_clock) ->

{Total_Wallclock_Time,

Wallclock_Time_Since_Last_Call}

类型

返回有关挂钟的信息。除了与运行时间或CPU时间相反的实时测量值之外，wall_clock可以按照与runtime相同的方式使用

erlang:suspend_process(Suspendee) -> true

类型

暂停确定的过程Suspendee。就如调用erlang:suspend_process(Suspendee, [])。

警告

此BIF仅用于调试。

erlang:suspend_process(Suspendee, OptList) -> boolean()

类型

如果尚未处于该状态，则增加由其标识的进程的挂起计数并将其置于挂起状态。暂停的进程不会计划执行，直到进程恢复。

一个进程可以被多个进程暂停，并且可以被一个进程暂停多次。挂起的进程不会离开挂起状态，直到挂起计数达到零。Suspendee当erlang:resume_process(Suspendee)被调用的相同的erlang:suspend_process(Suspendee)进程调用时，暂停计数减少。当进程终止时，所有增加的进程获取的其他进程的暂停计数都会自动减少。

Options (Opts):

asynchronous

挂起请求被发送到由标识的进程Suspendee。Suspendee最终会暂停，除非它可以暂停之前恢复。erlang:suspend_process/2无论是否Suspendee已暂停，都立即返回调用者。Suspendee暂停的时间点不能从系统中的其他事件推断出来。只有保证Suspendee 最终会暂停（除非恢复）。如果选择asynchronous了不被通过，调用者erlang:suspend_process/2被阻塞，直到Suspendee已暂停。

unless_suspending

除非调用过程已经暂停，否则由过程Suspendee标识的过程将被暂停Suspendee。如果unless_suspending与选项结合使用asynchronous，除非呼叫进程已挂起，Suspendee或者暂停请求已经发送并且正在传送，否则发送暂停请求。如果呼叫过程已经挂起Suspendee，或者如果与选项结合asynchronous并且发送请求已在运输中，false则被返回并且暂停计数Suspendee保持不变。

如果由标识的进程的暂停计数Suspendee增加，true则被返回，否则false。

警告

此BIF仅用于调试。

失败：

badarg 如果Suspendee不是进程标识符。

badarg 如果标识的Suspendee进程与进程调用是相同的进程erlang:suspend_process/2。

badarg 如果标识的过程Suspendee不存在。

badarg 如果标识的进程Suspendee驻留在另一个节点上。 badarg 如果OptList不是有效的Opts 的正确列表。 system_limit 如果Suspendee由调用进程标识的进程已被暂停多次，可能会由当前使用的内部数据结构表示。系统限制超过20亿人次，永远不会降低。

erlang：system_flag（Flag :: backtrace_depth，Depth） - > OldDepth

类型

设置'EXIT'元组的退出原因元素中调用堆栈回溯的最大深度。该标志还会限制process_info项目返回的堆栈跟踪深度current_stacktrace.

返回标志的旧值。

erlang:system_flag(Flag :: cpu_topology, CpuTopology) ->

OldCpuTopology

类型

警告

此参数已被弃用。如果不使用这种说法，使用命令行参数+sct在erl(1)。

当这个参数被移除时，在仿真器启动时确定要使用的最终CPU拓扑。

设置用户定义的CpuTopology。用户定义的CPU拓扑覆盖任何自动检测到的CPU拓扑。通过使undefined作为CpuTopology，系统恢复到自动检测到CPU的拓扑结构。返回的值等于erlang:system_info(cpu_topology)更改前返回的值。

返回标志的旧值。

将调度程序绑定到逻辑处理器时使用CPU拓扑。如果调度程序在CPU拓扑更改时已经被绑定，调度程序将根据新的CPU拓扑发送重新绑定请求。

用户定义的CPU拓扑也可以通过传递命令行参数+sct来设置erl(1)。

有关类型CpuTopology等的信息，请参阅erlang:system_info(cpu_topology)以及命令行标志+sct和在erl(1)中的+sbt

erlang：system_flag（Flag :: dirty_cpu_schedulers_online，

DirtyCPUSchedulersOnline） - >

OldDirtyCPUSchedulersOnline

类型

在线设置CPU调度程序的数量。范围1 <= DirtyCPUSchedulersOnline <= N，其中N最小的返回值的erlang:system_info(dirty_cpu_schedulers)和erlang:system_info(schedulers_online)。

返回标志的旧值。

如果联机调度程序的数量发生更改，则联机CPU调度程序的数量可能会更改。例如，如果12个调度程序和6个CPU调度程序联机，并且system_flag/2用于将调度程序联机数设置为6，则联机脏CPU调度程序的数量也会自动减少一半，最多减少到3个。同样，如果在线CPU调度器的数量与在线调度器数量的增加成比例地增加。

有关更多信息，请参阅erlang:system_info(dirty_cpu_schedulers)和erlang:system_info(dirty_cpu_schedulers_online)。

erlang：system_flag（Flag :: fullsweep_after，Number） - > OldNumber

类型

设置系统标志fullsweep_after。Number是一个非负整数，指示可以在不强制fullsweep集合的情况下完成分代垃圾收集的次数。该值适用于新进程，而已经运行的进程不受影响。

返回标志的旧值。

在低内存系统（尤其是没有虚拟内存）中，将值设置为0可以帮助节省内存。

该值也可以通过（OS）环境变量来设置ERL_FULLSWEEP_AFTER。

erlang：system_flag（Flag :: microstate_accounting，Action） - >

OldState

类型

打开/关闭微状态会计测量。当通过重置时，所有计数器都重置为0。

欲了解更多信息，请参阅statistics(microstate_accounting)。

erlang:system_flag(Flag :: min_heap_size, MinHeapSize) ->

OldMinHeapSize

类型

设置进程的默认最小堆大小。大小用文字指定。新的min_heap_size效果只会在更改完成后产生min_heap_size。min_heap_size可以通过使用spawn_opt/4或设置为单个进程process_flag/2。

返回标志的旧值。

erlang：system_flag（Flag :: min_bin_vheap_size，MinBinVHeapSize） - >

OldMinBinVHeapSize

类型

为进程设置默认的最小二进制虚拟堆大小。大小用文字指定。新的min_bin_vhheap_size效果只会在更改完成后产生min_bin_vheap_size。min_bin_vheap_size可以通过使用spawn_opt/2,3,4或设置为单个进程process_flag/2。

返回标志的旧值。

erlang：system_flag（Flag :: max_heap_size，MaxHeapSize） - >

OldMaxHeapSize

类型

设置进程的默认最大堆大小设置。大小用文字指定。新的max_heap_size效果只有在更改完成后才会产生。max_heap_size可以使用spawn_opt/2,3,4或设置为单个进程process_flag/2。

返回标志的旧值。

erlang：system_flag（Flag :: multi_scheduling，BlockState） - >

OldBlockState

类型

如果启用多计划，模拟器将使用多个计划程序线程。可以通过两种不同的方式阻止多计划。除一个调度程序被阻塞外，或者所有正常的调度程序都被阻塞。当只有正常的调度程序被阻塞时，脏调度程序可以自由地继续安排进程。

如果BlockState =:= block，多计划被阻止。也就是说，只有一个调度程序线程会执行。如果BlockState =:= unblock没有其他人阻止多重调度，并且该过程仅阻塞一次，则多重调度被解除阻塞。

如果BlockState =:= block_normal正常的多计划被阻止。也就是说，只有一个正常的调度程序线程会执行，但是可以执行多个调度程序。如果BlockState =:= unblock_normal没有其他阻塞正常的多重调度，并且该过程仅阻塞一次，则解除正常的多重调度。

一个进程可以多次阻塞多进程调度和正常多进程调度。如果一个进程被多次阻塞，在释放多进程调度块之前，它必须被阻塞的次数与阻塞的次数一样多。如果阻塞多进程或正常多进程的进程退出，它会自动释放其阻塞的多进程调度和正常的多进程调度。

返回值是disabled，blocked，blocked_normal，或enabled。返回的值描述调用完成后的状态erlang:system_flag(multi_scheduling, BlockState)。有关返回值的信息，请参阅erlang:system_info(multi_scheduling)。

注意

通常不需要阻塞多调度和正常的多调度。如果您觉得需要使用这些功能，请再次考虑更多次。阻塞多重调度只是作为最后的手段，因为它很可能是解决问题的一种非常低效的方式。

另见erlang:system_info(multi_scheduling)，erlang:system_info(normal_multi_scheduling_blockers)，erlang:system_info(multi_scheduling_blockers)，和erlang:system_info(schedulers)。

erlang:system_flag(Flag :: scheduler_bind_type, How) ->

OldBindType

类型

警告

此参数已被弃用。如果不使用这种说法，使用命令行参数+sbt在erl(1)。当这个参数被删除时，在仿真器启动时确定要使用的最终调度器绑定类型。

控制调度程序是否以及如何绑定到逻辑处理器。

当erlang:system_flag(scheduler_bind_type, How)被调用，异步信号会在线发送给所有调度程序，导致它们尝试根据请求绑定或取消绑定。

注意

如果调度程序未能绑定，通常会被忽略，因为验证有效的逻辑处理器标识符并不总是可能的。如果报告了错误，则会报告error_logger。要验证调度程序是否按要求绑定，请调用erlang:system_info(scheduler_bindings)。

调度程序可以绑定在较新的Linux，Solaris，FreeBSD和Windows系统上，但在未来的版本中将支持更多的系统。

为了使运行时系统能够绑定调度程序，必须知道CPU拓扑。如果运行时系统无法自动检测CPU拓扑，则可以定义它。有关如何定义CPU拓扑结构的详细信息，请参阅命令行标志在erl(1)中的+sct

运行时系统默认不会将调度程序绑定到逻辑处理器。

注意

如果Erlang运行时系统是逻辑处理器唯一的OS进程绑定线程，则这会提高运行时系统的性能。但是，如果其他OS进程（例如另一个Erlang运行时系统）也将线程绑定到逻辑处理器，则可能会导致性能损失。有时候这种表现可能会很严重。如果是这样，建议不要绑定调度程序。

调度程序可以用不同的方式绑定。参数How确定调度程序的绑定方式，可以是以下任何一种：

unbound相同的命令行参数+sbt u在erl(1)。

no_spread相同的命令行参数+sbt ns在erl(1)。 thread_spread相同的命令行参数+sbt ts在erl(1)。 processor_spread相同的命令行参数+sbt ps在erl(1)。 spread相同的命令行参数+sbt s在erl(1)。 no_node_thread_spread相同的命令行参数+sbt nnts在erl(1)。

no_node_processor_spread相同的命令行参数+sbt nnps在erl(1)。

thread_no_node_processor_spread相同的命令行参数+sbt tnnps在erl(1)。

default_bind相同的命令行参数+sbt db在erl(1)。

返回的值等于How标志scheduler_bind_type更改前的值

失败：

notsup如果调度程序的绑定不受支持。

badarg如果How不是其中一个备案文件。

badarg如果CPU拓扑信息不可用。

调度程序绑定类型也可以通过传递命令行参数+sbt来设置erl(1)。

有关更多信息，请参阅erlang:system_info(scheduler_bind_type)，erlang:system_info(scheduler_bindings)以及命令行标志+sbt和+sct英寸erl(1)。

erlang:system_flag(Flag :: scheduler_wall_time, Boolean) ->

OldBoolean

类型

打开或关闭调度程序挂墙时间测量。

有关更多信息，请参阅statistics(scheduler_wall_time)。

erlang:system_flag(Flag :: schedulers_online, SchedulersOnline) ->

OldSchedulersOnline

类型

设置在线调度程序的数量。范围是1 <= SchedulersOnline <= erlang:system_info(schedulers)。

返回标志的旧值。

如果仿真器是在支持的情况下构建的dirty schedulers，则更改在线调度程序的数量还可以更改在线的CPU调度程序的数量。例如，如果12个调度程序和6个脏CPU调度程序联机，并且system_flag/2用于将调度程序联机数设置为6，则联机脏CPU调度程序的数量也会自动减少一半，最多减少到3个。同样，如果在线脏CPU调度器的数量与在线调度器数量的增加成比例地增加。

有关更多信息，请参阅erlang:system_info(schedulers)和erlang:system_info(schedulers_online)。

erlang：system_flag（Flag :: trace_control_word，TCW） - > OldTCW

类型

将节点跟踪控制字的值设置为TCW无符号整数。有关更多信息，请参见set_tcw“用户指南”中的“Erlang中的匹配规范”一节中的功能。

返回标志的旧值。

erlang：system_flag（Flag :: time_offset，Value :: finalize） - >

OldState

类型

当single time warp mode使用时确定time offset。如果使用其他时间扭曲模式，则时间偏移状态保持不变。

返回旧的状态标识符，即：

• 如果返回preliminary，则执行完成并且时间偏移现在是最终的。

• 如果返回final，则时间偏移已经处于最终状态。这是因为另一个erlang:system_flag(time_offset, finalize)被调用或因为no time warp mode被使用。

• 如果volatile返回，则由于multi-time warp modeused.erlang：system_info（Item :: allocated_areas） - > tuple（）erlang：system_info（Item :: allocator） - > {Allocator，Version，Features，Settings} erlang： system_info（Item :: alloc_util_allocators） - > Allocerlang：system_info（Item :: {allocator，Alloc}） - > term（）erlang：system_info（Item :: {allocator_sizes，Alloc}） - > term（）TypesReturns有关当前系统的分配器（仿真器）按以下规定Item： allocated_areas 返回包含其他分配内存区域信息的元组列表。每个元组包含一个原子，该原子将内存类型描述为第一个元素，并将分配的内存量（以字节为单位）作为第二个元素。当存在有关已分配和已用内存的信息时，还会出现第三个元素，其中包含以字节为单位的已用内存量。erlang:system_info(allocated_areas)旨在用于调试，并且内容高度依赖于实施。因此，结果的内容会在需要时更改，恕不另行通知。注意这些值的总和不是模拟器分配的总内存量。有些值是其他值的一部分，有些存储区不是结果的一部分。有关由仿真器分配的总内存量的信息，请参阅erlang:memory/0,1。

allocator 返回{Allocator, Version, Features, Settings，其中：

• Allocator对应于所malloc()使用的实现。如果Allocator等于undefined，则malloc()所使用的实现无法识别。glibc可以被识别。

• Version是表示所用malloc()实现版本的整数列表（但不是字符串）。

• Features 是代表使用的分配特征的原子列表。

• Settings是子系统列表，它们的可配置参数和使用的值。设置可以在平台，分配器和分配功能的不同组合之间有所不同。内存大小以字节为单位给出。另请参见“系统标志影响erts_alloc” erts_alloc(3)。 alloc_util_allocators 返回使用ERTS内部alloc_util框架作为原子的所有分配器的名称列表。欲了解更多信息，请参见The alloc_util framework在erts_alloc(3)。 {allocator, Alloc} 返回有关指定分配器的信息。从ERTS 5.6.1开始，返回值是一个{instance, InstanceNo, InstanceInfo}元组列表，其中InstanceInfo包含有关分配器特定实例的信息。如果Alloc不是公认的分配器，undefined则返回。如果Alloc被禁用，false返回。通知返回的信息是高度依赖于实施的，可随时更改或删除，恕不另行通知。它最初是作为开发新的分配器时的一种工具，但由于它可能对其他人感兴趣，所以它已被简要记录。公认的分配器被列入erts_alloc(3)。关于超级载体的信息可以从ERTS 8.0 {allocator, erts_mmap}或者从ERTS 5.10.4获得; 返回的列表在调用时{allocator, mseg_alloc}也包含一个{erts_mmap, _}元组作为列表中的一个元素。在阅读完erts_alloc(3)文档后，返回的信息或多或少都会说明问题，但值得说明一些事情。呼叫计数由两个值表示，第一个值是千兆调用，第二个值是调用得到的。mbcs和sbcs分别表示多块载波和单块载波。大小以字节表示。当尺寸没有出现时，它就是一些东西。大小和数目通常由三个值表示：

• 首先是当前值。

• 第二个是自上次调用以来的最大值erlang:system_info({allocator, Alloc})。

• 第三个是模拟器启动以来的最大值。

如果只存在一个值，则它是当前值。fix_alloc内存块类型由两个值表示。第一个值是内存池大小，第二个值是已用内存大小。

{allocator_sizes, Alloc}

返回指定分配器的各种大小信息。返回的信息是由返回的信息的子集erlang:system_info({allocator,Alloc})。

erlang：system_info（Item :: cpu_topology） - > CpuTopology

erlang：system_info（Item ::

{cpu_topology, defined | detected | used}) ->

CpuTopology

类型

All `LevelEntry`s of a list must contain the same `LevelTag`, except on the top level where both `node` and `processor` `LevelTag`s can coexist.    `{LevelTag, SubLevel} == {LevelTag, [], SubLevel}`    More `LevelTag`s can be introduced in a future release.     The `info_list()` can be extended in a future release.  

返回有关当前系统（仿真器）的CPU拓扑结构的各种信息，Item如下所示：

cpu_topology

返回CpuTopology模拟器当前使用的内容。将调度程序绑定到逻辑处理器时使用CPU拓扑。所使用的CPU拓扑是user-defined CPU topology（如果存在），否则automatically detected CPU topology（如果存在）。如果不存在CPU拓扑，undefined则被返回。

node指非统一内存访问（NUMA）节点。thread指的是硬件线程（例如，英特尔超线程）。

CpuTopology如果只有一个条目存在且InfoList为空，则可以省略术语级别。

thread只能是一个分层次的core。core可以是一个次级到processor或node。processor可以在最高层或一个子层面上node。node可以在最高层或一个子层面上processor。也就是说，NUMA节点可以是处理器内部处理器或外部处理器。只要每个逻辑CPU属于一个 NUMA节点，CPU拓扑就可以由处理器内部和外部NUMA节点组成。缓存层次结构不是该CpuTopology类型的一部分，但将在未来的版本中。其他的东西也可以在未来的版本中进入CPU拓扑。所以，期待CpuTopology类型改变。

{cpu_topology, defined}

返回用户定义的CpuTopology。有关更多信息，请参见+sctin erl(1)和argument中的命令行标志cpu_topology。

{cpu_topology, detected}

返回自动检测到的CpuTopologyy。仿真器在一些较新的Linux，Solaris，FreeBSD和Windows系统上检测CPU拓扑。在具有32个以上逻辑处理器的Windows系统上，未检测到CPU拓扑。

有关更多信息，请参阅参数cpu_topology。

{cpu_topology, used}

CpuTopology模拟器使用的返回值。有关更多信息，请参阅参数cpu_topology。

erlang:system_info(Item :: fullsweep_after) ->

{fullsweep_after, integer() >= 0}

erlang:system_info(Item :: garbage_collection) ->

{atom(), integer()}

erlang:system_info(Item :: max_heap_size) ->

{max_heap_size,

MaxHeapSize :: max_heap_size()}

erlang:system_info(Item :: message_queue_data) ->

message_queue_data()

erlang:system_info(Item :: min_heap_size) ->

{min_heap_size,

MinHeapSize :: integer() >= 1}

erlang:system_info(Item :: min_bin_vheap_size) ->

{min_bin_vheap_size,

MinBinVHeapSize :: integer() >= 1}

类型

返回有关默认进程堆设置的信息：

fullsweep_after

返回{fullsweep_after, integer() >= 0}，fullsweep_after默认使用的是垃圾收集设置。有关更多信息，请参见garbage_collection下面的描述。

garbage_collection

返回描述默认垃圾回收设置的列表。由本地节点生成的进程spawn或spawn_link使用这些垃圾收集设置。默认设置可以通过使用更改erlang:system_flag/2。spawn_opt/2,3,4可以产生一个不使用默认设置的进程。

max_heap_size

返回{max_heap_size, MaxHeapSize}，其中MaxHeapSize是产生的进程的当前系统范围最大堆大小设置。此设置可以使用命令行标志被设置+hmax，+hmaxk与+hmaxel在erl(1)中。它也可以在运行时使用erlang:system_flag(max_heap_size, MaxHeapSize)。有关max_heap_size进程标志的更多详细信息，请参阅process_flag(max_heap_size, MaxHeapSize)。

message_queue_data

返回message_queue_data进程标志的默认值，这是off_heap或者on_heap。这个默认值由命令行参数设定+hmqd在erl(1)。有关message_queue_data进程标志的更多信息，请参阅文档process_flag(message_queue_data, MQD)。

min_heap_size

返回{min_heap_size, MinHeapSize}，其中MinHeapSize是产生的进程的当前系统范围最小堆大小。

min_bin_vheap_size

返回{min_bin_vheap_size, MinBinVHeapSize}，其中MinBinVHeapSize是产生的进程的当前系统范围的最小二进制虚拟堆大小。

erlang:system_info(Item :: atom_count) -> integer() >= 1

erlang:system_info(Item :: atom_limit) -> integer() >= 1

erlang:system_info(Item :: build_type) ->

opt |

debug |

purify |

quantify |

purecov |

gcov |

valgrind |

gprof |

lcnt |

frmptr

erlang:system_info(Item :: c_compiler_used) -> {atom(), term()}

erlang:system_info(Item :: check_io) -> term()

erlang:system_info(Item :: compat_rel) -> integer()

erlang:system_info(Item :: creation) -> integer()

erlang:system_info(Item :: debug_compiled) -> boolean()

erlang:system_info(Item :: delayed_node_table_gc) ->

infinity | integer() >= 0

erlang:system_info(Item :: dirty_cpu_schedulers) ->

integer() >= 0

erlang:system_info(Item :: dirty_cpu_schedulers_online) ->

integer() >= 0

erlang:system_info(Item :: dirty_io_schedulers) ->

integer() >= 0

erlang:system_info(Item :: dist) -> binary()

erlang:system_info(Item :: dist_buf_busy_limit) ->

integer() >= 0

erlang:system_info(Item :: dist_ctrl) ->

{Node :: node(),

ControllingEntity :: port() | pid()}

erlang:system_info(Item :: driver_version) -> string()

erlang:system_info(Item :: dynamic_trace) ->

none | dtrace | systemtap

erlang:system_info(Item :: dynamic_trace_probes) -> boolean()

erlang:system_info(Item :: elib_malloc) -> false

erlang:system_info(Item :: eager_check_io) -> boolean()

erlang:system_info(Item :: ets_limit) -> integer() >= 1

erlang:system_info(Item :: heap_sizes) -> integer() >= 0

erlang:system_info(Item :: heap_type) -> private

erlang:system_info(Item :: info) -> binary()

erlang:system_info(Item :: kernel_poll) -> boolean()

erlang:system_info(Item :: loaded) -> binary()

erlang:system_info(Item ::

erlang:system_info(Item ::

logical_processors_available |

logical_processors_online) ->

unknown | integer() >= 1

erlang:system_info(Item :: machine) -> string()

erlang:system_info(Item :: modified_timing_level) ->

integer() | undefined

erlang:system_info(Item :: multi_scheduling) ->

disabled |

blocked |

blocked |

enabled

erlang:system_info(Item :: multi_scheduling_blockers) ->

Pid :: pid()

erlang:system_info(Item :: nif_version) -> string()

erlang:system_info(Item :: normal_multi_scheduling_blockers) ->

Pid :: pid()

erlang:system_info(Item :: otp_release) -> string()

erlang:system_info(Item :: os_monotonic_time_source) ->

{atom(), term()}

erlang:system_info(Item :: os_system_time_source) ->

{atom(), term()}

erlang:system_info(Item :: port_count) -> integer() >= 0

erlang:system_info(Item :: port_limit) -> integer() >= 1

erlang:system_info(Item :: process_count) -> integer() >= 1

erlang:system_info(Item :: process_limit) -> integer() >= 1

erlang:system_info(Item :: procs) -> binary()

erlang:system_info(Item :: scheduler_bind_type) ->

spread |

processor_spread |

thread_spread |

thread_no_node_processor_spread |

no_node_processor_spread |

no_node_thread_spread |

no_spread |

unbound

erlang:system_info(Item :: scheduler_bindings) -> tuple()

erlang:system_info(Item :: scheduler_id) ->

SchedulerId :: integer() >= 1

erlang:system_info(Item :: schedulers | schedulers_online) ->

integer() >= 1

erlang:system_info(Item :: smp_support) -> boolean()

erlang:system_info(Item :: start_time) -> integer()

erlang:system_info(Item :: system_version) -> string()

erlang:system_info(Item :: system_architecture) -> string()

erlang:system_info(Item :: threads) -> boolean()

erlang:system_info(Item :: thread_pool_size) -> integer() >= 0

erlang:system_info(Item :: time_correction) -> true | false

erlang:system_info(Item :: time_offset) ->

preliminary | final | volatile

erlang:system_info(Item :: time_warp_mode) ->

no_time_warp |

single_time_warp |

multi_time_warp

erlang:system_info(Item :: tolerant_timeofday) ->

enabled | disabled

erlang:system_info(Item :: trace_control_word) ->

integer() >= 0

erlang:system_info(Item :: update_cpu_info) -> changed | unchanged

erlang:system_info(Item :: version) -> string()

按照以下指定返回有关当前系统（模拟器）的各种信息Item：

atom_count

返回本地节点上当前存在的原子数。该值以整数形式给出。

atom_limit

返回允许的最大原子数。这个限制可以在启动时通过命令行标志，增加+t至erl(1)。

build_type

返回描述运行时系统构建类型的原子。这通常是opt优化的原子。其他可能的返回值是debug，purify，quantify，purecov，gcov，valgrind，gprof，和lcnt。可能的返回值可以随时添加或删除，恕不另行通知。

c_compiler_used

返回描述编译运行时系统时使用的C编译器的二元组。第一个元素是描述编译器名称的原子，或者undefined是未知的。第二个元素是描述编译器版本的术语，或者undefined是未知的。

check_io

返回包含有关仿真器内部I / O检查的其他信息的列表。请注意，返回列表的内容可能随着时间的推移而在不同平台之间有所不同 只保证返回一个列表。

compat_rel

以整数形式返回本地节点的兼容性模式。返回的整数代表当前模拟器已被设置为向后兼容的Erlang / OTP版本。兼容模式可以在启动时通过使用命令行标记被配置+R在erl(1)。

cpu_topology

参阅above。

creation

以整数形式返回本地节点的创建。当节点重新启动时，创建将发生变化。创建节点存储在过程标识符，端口标识符和引用中。这使得（在某种程度上）可以区分来自节点的不同化身的标识符。有效的创建是1到3范围内的整数，但在将来的版本中可能会更改。如果节点不活动，0则被返回。

debug_compiled

如果仿真器已被调试编译，则返回true，否则返回false。

delayed_node_table_gc

以秒为单位返回节点表中条目的垃圾回收延迟。这个限制可以在启动时通过传递命令行标志+zdntgc来设置erl(1)。有关更多信息，请参阅命令行标志的文档。

dirty_cpu_schedulers

返回模拟器使用的脏CPU调度程序线程的数量。肮脏的CPU调度程序执行CPU限制的本地函数，如NIF，链接的驱动程序代码和无法由普通模拟器调度程序干净地管理的BIF。

CPU调度程序线程的数量在模拟器启动时确定，并且在此之后无法更改。但是，可以随时更改联机脏CPU调度程序线程的数量。可以在启动时通过传递命令行标志+SDcpu或+SDPcpuin 来设置脏CPU调度程序的数量erl(1)。

另见erlang:system_flag(dirty_cpu_schedulers_online, DirtyCPUSchedulersOnline)，erlang:system_info(dirty_cpu_schedulers_online)，erlang:system_info(dirty_io_schedulers)，erlang:system_info(schedulers)，erlang:system_info(schedulers_online)，和erlang:system_flag(schedulers_online, SchedulersOnline)。

dirty_cpu_schedulers_online

返回联机CPU调度程序的数量。返回值满足1 <= DirtyCPUSchedulersOnline <= N，其中N最小的返回值的erlang:system_info(dirty_cpu_schedulers)和erlang:system_info(schedulers_online)。

通过传入命令行标志+SDcpu，可以在启动时设置联机CPU调度程序的数量erl(1)。

欲了解更多信息，请参见erlang:system_info(dirty_cpu_schedulers)，erlang:system_info(dirty_io_schedulers)，erlang:system_info(schedulers_online)，和erlang:system_flag(dirty_cpu_schedulers_online, DirtyCPUSchedulersOnline)。

dirty_io_schedulers

以整数形式返回I / O调度程序的数量。I / O调度程序执行I / O限制的本地函数，例如NIF和链接的驱动程序代码，这些代码无法由普通模拟器调度程序干净地管理。

通过传入命令行参数+SDio，可以在启动时设置此值erl(1)。

欲了解更多信息，请参见erlang:system_info(dirty_cpu_schedulers)，erlang:system_info(dirty_cpu_schedulers_online)和erlang:system_flag(dirty_cpu_schedulers_online, DirtyCPUSchedulersOnline)。

dist

返回一个包含格式与Erlang崩溃转储格式相同的分发信息字符串的二进制文件。有关更多信息，请参阅How to interpret the Erlang crash dumps用户指南中的部分。

dist_buf_busy_limit

以字节为单位返回分配缓冲区忙限制的值。这个限制可以在启动时通过传递命令行标志+zdbbl来设置erl(1)。

dist_ctrl

返回元组列表，{Node, ControllingEntity}每个连接的远程节点都有一个条目。Node是节点名称，ControllingEntity是负责与该节点通信的端口或进程标识符。更具体地说，ControllingEntity对于通过TCP / IP连接的节点（正常情况）是与特定节点通信时使用的套接字。

driver_version

返回包含运行时系统使用的Erlang驱动程序版本的字符串。它有形式"<major ver>.<minor ver>"。

dynamic_trace

返回描述编译到虚拟机中的动态跟踪框架的原子。它可以是dtrace，systemtap或none。对于商业或标准构建而言，它总是如此none。其他返回值指示自定义配置（例如，./configure --with-dynamic-trace=dtrace）。有关动态跟踪的更多信息，请参阅dyntrace(3)手册页和Erlang源代码顶层目录中的README.dtrace/ README.systemtapfiles。

dynamic_trace_probes

返回一个boolean()指示，如果动态跟踪探针（dtrace或systemtap）内置到仿真器中。这只能true在虚拟机是为动态跟踪（即system_info(dynamic_trace)返回dtrace或systemtap）而构建的。

end_time

最后Erlang monotonic time在native time unit能够在内部目前Erlang运行时系统实例来表示。start time和结束时间之间的时间是至少一千年的四分之一。

elib_malloc

此选项将在未来版本中删除。随着elib_malloc分配器已被删除，返回值将始终为false。

eager_check_io

返回的命令行标志的值+secio在erl(1)，其是true或false。有关不同值的信息，请参阅命令行标志的文档。

ets_limit

返回允许的ETS表的最大数量。通过在启动Erlang运行时系统之前将命令行标志传递+e给erl(1)或通过设置环境变量ERL_MAX_ETS_TABLES，可以在启动时增加此限制。

heap_sizes

以字为单位返回表示有效堆大小的整数列表。所有Erlang堆的大小都在此列表中。

heap_type

返回当前模拟器使用的堆类型。存在一个堆类型：

private 每个进程都有一个为其使用而保留的堆，并且不允许在不同进程的堆之间进行引用。在进程之间传递的消息在堆之间复制。 info

返回一个包含一系列其他系统信息的二进制文件，格式如Erlang故障转储。有关更多信息，请参阅How to interpret the Erlang crash dumps用户指南中的部分。

kernel_poll

如果模拟器使用某种内核轮询实现，则返回true;否则返回false。

loaded

返回一个包含加载模块信息字符串的二进制文件，格式与Erlang故障转储相同。有关更多信息，请参阅How to interpret the Erlang crash dumps用户指南中的部分。

logical_processors

返回检测到的系统中配置的逻辑处理器数量。如果仿真器无法检测到配置的逻辑处理器，则返回值是整数或原子unknown。

logical_processors_available

返回检测到的Erlang运行时系统可用的逻辑处理器数量。如果仿真器无法检测到可用的逻辑处理器，则返回值为整数或原子unknown。可用逻辑处理器的数量小于或等于数量logical processors online。

logical_processors_online

返回系统中检测到的逻辑处理器数量。如果仿真器无法在线检测逻辑处理器，则返回值为整数或原子unknown。在线逻辑处理器的数量小于或等于数量logical processors configured。

machine

返回一个包含Erlang机器名称的字符串。

modified_timing_level

如果修改时间已启用，则返回修改后的时间级别（整数），否则返回undefined。有关修正的定时的更多信息，请参见在erl(1)的命令行标志+T

multi_scheduling

返回以下内容之一：

disabled

该仿真器只有一个调度程序线程。仿真器没有SMP支持，或者只有一个调度程序线程启动。

blocked

仿真器具有多个调度程序线程，但除一个调度程序线程外，所有调度程序线程都被阻止。也就是说，只有一个调度程序线程调度Erlang进程并执行Erlang代码。

blocked_normal

模拟器具有多个调度程序线程，但除一个之外的所有正常调度程序线程都被阻止。注意脏的调度程序没有被阻塞，并且可以调度Erlang进程并执行本地代码。

enabled

模拟器有多个调度程序线程，并且没有调度程序线程被阻塞。也就是说，所有可用的调度程序线程都会安排Erlang进程并执行Erlang代码。

另见erlang:system_flag(multi_scheduling, BlockState)，erlang:system_info(multi_scheduling_blockers)，erlang:system_info(normal_multi_scheduling_blockers)，和erlang:system_info(schedulers)。

multi_scheduling_blockers

阻塞多计划时的s 列表，返回Pid，否则返回空列表。Pid列表中的s表示当前阻止多计划的所有进程。Pid在列表中仅出现一次，即使相应的过程已阻止多次。

另见erlang:system_flag(multi_scheduling, BlockState)，erlang:system_info(multi_scheduling)，erlang:system_info(normal_multi_scheduling_blockers)，和erlang:system_info(schedulers)。

nif_version

返回包含运行时系统使用的Erlang NIF接口版本的字符串。它的格式是“<major ver>。<minor ver>”。

normal_multi_scheduling_blockers

阻塞正常多计划时的s 列表，返回Pid（即所有正常计划程序都被阻止），否则返回空列表。Pid列表中的s表示当前阻止正常多计划的所有进程。Pid在列表中仅出现一次，即使相应的过程已阻止多次。

另见erlang:system_flag(multi_scheduling, BlockState)，erlang:system_info(multi_scheduling)，erlang:system_info(multi_scheduling_blockers)，和erlang:system_info(schedulers)。

otp_release

返回一个字符串，其中包含当前正在执行的ERTS应用程序所属的OTP版本的OTP版本号。

从Erlang / OTP 17开始，OTP版本号对应于主要的OTP版本号。没有erlang:system_info()参数给出确切的OTP版本。这是因为一般情况下的确切OTP版本很难确定。有关更多信息，请参阅System principles系统文档中的版本说明。

os_monotonic_time_source

返回包含有关OS monotonic time运行时系统使用的源的信息的列表。

如果[]被返回，则没有OS单调时间可用。该列表包含Keys为第一个元素和Values为第二个元素的二元组。这些元组的顺序是未定义的。以下元组可以成为列表的一部分，但将来可以引入更多的元组：

{function, Function}

Function是使用的函数的名称。如果操作系统单调时间可用于运行时系统，则此元组始终存在。

{clock_id, ClockId}

这个元组只有在Function可以与不同的时钟一起使用时才存在。ClockId对应于调用时使用的时钟标识符Function。

{resolution, OsMonotonicTimeResolution}

resolution当前操作系统单调时间源的最大可能值为每秒部分。如果不能从操作系统检索到分辨率信息，OsMonotonicTimeResolution则设置为Function返回值的时间单位的分辨率。也就是说，实际分辨率可能会低于OsMonotonicTimeResolution。请注意，该决议没有提及任何有关该决议的内容accuracy或是否precision与该决议一致。但是，你确实知道精度并不比OsMonotonicTimeResolution好

{extended, Extended}

Extended等于yes时间值的范围已经扩大; 否则Extended等于no。如果Function返回快速换行的值，则范围必须扩展。当返回值是一个32位值时，通常就是这种情况。

{parallel, Parallel}

如果Function从多个线程并行调用，Parallel等于yes。若Function从多个线程并行调用。如果不是并行调用，因为调用必须被序列化，Parallel等于no。

{time, OsMonotonicTime}

OsMonotonicTime等于当前操作系统单调时间native time unit。

**`os_system_time_source`**  

返回包含有关OS system time运行时系统使用的源的信息的列表。

该列表包含Keys为第一个元素和Values为第二个元素的二元组。这些元组未定义的顺序。以下元组可以成为列表的一部分，但将来可以引入更多的元组：

{function, Function}

Function 是使用的功能的名称。

{clock_id, ClockId}

只有在Function可以与不同的时钟一起使用时才存在。ClockId对应于调用时使用的时钟标识符Function。

{resolution, OsSystemTimeResolution}

resolution当前操作系统系统时间源的最大可能值为每秒部分。如果不能从操作系统检索到分辨率信息，OsSystemTimeResolution则设置为Function返回值的时间单位的分辨率。也就是说，实际分辨率可能会低于OsSystemTimeResolution。请注意，决议没有提及任何有关该决议的内容accuracy或是否precision与决议保持一致。但是，你确实知道精度并不比OsSystemTimeResolution好。

{parallel, Parallel}

如果函数是从多个线程并行调用的，则并行等于yes。 如果它不是并行调用的，因为调用需要被序列化，Parallel等于no。

{time, OsSystemTime}

OsSystemTime等于当前操作系统的系统时间native time unit。

**`port_parallelism`**  

返回使用的默认端口并行调度提示。欲了解更多信息，请参阅命令行参数在erl(1)的+spp。

port_count

返回本地节点上当前存在的端口数。该值以整数形式给出。这与返回的值length(erlang:ports())相同，但效率更高。

port_limit

以整数形式返回本地节点上同时存在的最大端口数。这个限制可以在启动时通过使用命令行标记被配置+Q在erl(1)。

process_count

返回本地节点上当前存在的进程数量。 该值以整数形式给出。 这与length（processes（））返回的值相同，但效率更高。

process_limit

返回本地节点上同时存在的最大进程数。 该值以整数形式给出。 该限制可以在启动时通过在erl（1）中使用命令行标志+ P来配置。

procs

返回一个二进制文件，其中包含格式化为Erlang故障转储格式的进程和端口信息的字符串。 有关更多信息，请参见用户指南中的如何解释Erlang故障转储部分。

scheduler_bind_type

返回有关用户如何请求调度程序绑定或未绑定的信息。

请注意，尽管用户请求调度程序进行绑定，但他们可以默默无法绑定。要检查调度程序绑定，请调用erlang:system_info(scheduler_bindings)。

有关更多信息，请参阅+sbtin erl(1)和中的命令行参数erlang:system_info(scheduler_bindings)。

scheduler_bindings

返回有关当前使用的调度程序绑定的信息。

返回大小等于erlang：system_info（调度程序）的元组。 元组元素是整数或原子未绑定。 逻辑处理器标识符表示为整数。 例如，如果调度程序被绑定，则元素（erlang：system_info（scheduler_id），erlang：system_info（scheduler_bindings））返回标识符，该元素的标识符等于N的调度程序的当前绑定。 调用进程正在执行的逻辑处理器。

请注意，只有联机调度程序可以绑定到逻辑处理器。

有关更多信息，请参阅+sbtin erl(1)和erlang:system_info(schedulers_online)中的命令行参数。

scheduler_id

返回调用进程正在执行的调度程序线程的调度程序标识（SchedulerId）。 SchedulerId是一个正整数，其中1 <= SchedulerId <= erlang：system_info（调度程序）。

另见erlang:system_info(schedulers)。

schedulers

返回模拟器使用的调度程序线程数。调度程序线程在线调度Erlang进程和Erlang端口，并执行Erlang代码和Erlang链接的驱动程序代码。

调度程序线程的数量在模拟器启动时确定，以后不能更改。但是，可以随时更改在线调度程序的数量。

又见erlang:system_flag(schedulers_online, SchedulersOnline)，erlang:system_info(schedulers_online)，erlang:system_info(scheduler_id)，erlang:system_flag(multi_scheduling, BlockState)，erlang:system_info(multi_scheduling)，erlang:system_info(normal_multi_scheduling_blockers)和erlang:system_info(multi_scheduling_blockers)。

schedulers_online

返回在线调度程序的数量。调度程序的调度程序标识符在线满足关系1 <= SchedulerId <= erlang:system_info(schedulers_online)。

有关更多信息，请参阅erlang:system_info(schedulers)和erlang:system_flag(schedulers_online, SchedulersOnline)。

smp_support

如果仿真器已编译为支持SMP，则返回true，否则返回false。

start_time

当前Erlang运行时系统实例启动时以本地时间单位计的Erlang单调时间。

另见erlang:system_info(end_time)。

system_version

返回包含版本号和一些重要属性的字符串，例如调度程序的数量。

system_architecture

返回包含模拟器构建的处理器和操作系统体系结构的字符串。

threads

如果仿真器已使用线程支持编译，则返回true，否则返回false。

thread_pool_size

返回用于异步驱动程序调用（erl_driver:driver_async()）的异步线程池中的异步线程数。该值以整数形式给出。

time_correction

返回一个布尔值，指示是否启用时间校正。

time_offset

返回时间偏移的状态：

preliminary

时间偏移是初步的，将在稍后改变和完成。初步时间偏移量在初步阶段使用single time warp mode。

final

时间偏移是最终的。 这可能是因为没有使用时间扭曲模式，或者因为使用单次时间扭曲模式时已经完成了时间偏移。

volatile

时间偏移是不稳定的。也就是说，它可以在任何时候改变。这是因为multi-time warp mode使用。

 **`time_warp_mode`**  

返回标识所使用的时间扭曲模式的值：

no_time_warp使用无时间扭曲模式。

single_time_warp使用单时间扭曲模式。

multi_time_warp使用多时间扭曲模式。tolerant_timeofday

返回系统时间突然变化的预先ERTS 7.0向后兼容补偿是启用还是禁用。 当时间偏移是最终的时候启用这种补偿，并启用时间校正。

trace_control_word

返回节点跟踪控制字的值。 有关更多信息，请参阅用户指南中Erlang中的Match Specifications部分中的函数get_tcw。

update_cpu_info

运行时系统重新读取CPU信息的可用性和更新关于其内部存储的信息detected CPU topology和逻辑处理器的数量configured，online和available。

如果CPU信息自上次读取以来发生了变化，changed则返回原子，否则返回原子unchanged。如果CPU信息发生了变化，您可能想要adjust the number of schedulers online。您通常希望拥有与在线一样多的调度程序logical processors available。

version

返回包含模拟器版本号的字符串。

wordsize

同{wordsize, internal}。

{wordsize, internal}

以字节为单位返回Erlang术语字的大小，即以32位体系结构返回4，并在纯64位体系结构上返回8。在半字64位模拟器上，返回4，因为Erlang的条件是使用系统字大小一半的虚拟字大小存储的。

{wordsize, external}

返回模拟器的真实字大小，即指针的大小。该值以字节为单位给出整数。在纯粹的32位体系结构中，返回4。在半字和纯64位体系结构上，返回8。

注意

参数调度程序已将名称更改为scheduler_id，以避免与参数调度程序混淆。 参数调度程序在ERTS 5.5中引入，并在ERTS 5.5.1中重命名。

erlang:system_monitor() -> MonSettings

类型

返回由erlang：system_monitor / 2设置为{MonitorPid，Options}的当前系统监视设置，如果没有设置，则返回undefined。 选项的顺序可能与已设置的顺序不同。

erlang:system_monitor(Arg) -> MonSettings

类型

当用参数调用undefined时，所有系统性能监视设置都被清除。

以{MonitorPid，Options}作为参数调用函数与调用erlang：system_monitor（MonitorPid，Options）相同。

像以前一样返回以前的系统监视器设置erlang:system_monitor/0。

erlang:system_monitor(MonitorPid, Options) -> MonSettings

类型

设置系统性能监视选项。MonitorPid是本地进程标识符（pid）接收系统监视消息。第二个参数是监视选项列表：

{long_gc, Time}

如果系统中的垃圾回收至少需要Time挂钟毫秒，{monitor, GcPid, long_gc, Info}则会发送一条消息MonitorPid。GcPid是垃圾收集的pid。Info是描述垃圾收集结果的两元素元组列表。

其中一个元组是{timeout，GcTime}，其中GcTime是垃圾收集的时间，以毫秒为单位。 其他元组使用heap_size，heap_block_size，stack_size，mbuf_size，old_heap_size和old_heap_block_size进行标记。 这些元组在trace消息gc_minor_start的描述中进行了解释（请参阅erlang：trace / 3）。 可以添加新元组，并且可以随时更改信息列表中的元组顺序，恕不另行通知。

{long_schedule, Time}

如果系统中的某个进程或端口至少运行时间为毫秒，则会向MonitorPid发送一条消息{monitor，PidOrPort，long_schedule，Info}。 PidOrPort是正在运行的进程或端口。 Info是描述事件的两元素元组列表。

如果存在一个pid（），元组{{timeout，Millis}，{in，Location}和{out，Location}，其中Location是一个MFA（{Module，Function，Arity}）， 被安排进/出，或原子未定义。

如果存在port（），元组{timeout，Millis}和{port_op，Op}。 Op是proc_sig，timeout，input，output，event或dist_cmd之一，具体取决于执行哪个驱动程序回调。

proc_sig是一个内部操作，永远不会出现，而其他代表相应的驱动程序回调timeout，ready_input，ready_output，event和outputv（当端口被分发使用时）。 元组超时值Millis通知关于进程或端口的不间断执行时间，该时间始终等于或高于开始跟踪时提供的时间值。 新的元组可以添加到未来版本的Info列表中。 列表中元组的顺序可以随时更改，恕不另行通知。

这可用于检测NIF或执行时间过长的驱动程序的问题。1毫秒被认为是驱动程序回调或NIF的最佳时间。但是，分时系统通常会将所有<100毫秒视为“可能”和相当“正常”。但是，较长的日程安排时间可能表示交换或行为不当的NIF /驱动程序。行为不当的NIF和驱动程序可能会导致资源利用率不佳和整体系统性能不佳。

{large_heap, Size}

如果系统中的垃圾收集导致堆的分配大小至少为Size单词，{monitor, GcPid, large_heap, Info}则会向其发送消息MonitorPid。GcPid并且Info与long_gc之前的相同，只是标记的元组timeout不存在。

如果在垃圾收集后为所有堆生成分配的所有内存块的大小总和等于或高于此值，则会发送监视器消息Size。

当一个进程被max_heap_size杀死时，它在垃圾收集完成之前被杀死，因此不会发送大堆消息。

busy_port

如果在系统中的处理被暂停，因为它发送到一个繁忙的港口，一个消息{monitor, SusPid, busy_port, Port}被发送到MonitorPid。SusPid是发送时暂停的pid Port。

busy_dist_port

如果系统中的进程因发送到远程节点上的进程而被暂停，而该进程的节点间通信由繁忙端口处理，{monitor, SusPid, busy_dist_port, Port}则会向该进程发送消息MonitorPid。SusPid是通过节点间通信端口发送时暂停的pid Port。

像以前一样返回以前的系统监视器设置erlang:system_monitor/0。

注意

如果监视进程变得非常大以至于垃圾收集时它本身开始引起系统监视消息，则消息会放大进程消息队列并且可能使问题变得更糟。

保持监视过程整洁，不要将系统监视器限制设置得太紧。

失败：

badarg如果MonitorPid不存在。

badarg如果MonitorPid不是本地进程。

erlang:system_profile() -> ProfilerSettings

类型

返回由erlang:system_profile/2 设置的当前系统性能分析设置{ProfilerPid, Options}，或者undefined如果没有设置。选项的顺序可能与已设置的顺序不同。

erlang:system_profile(ProfilerPid, Options) -> ProfilerSettings

类型

设置系统分析器选项。ProfilerPid是本地进程标识符（pid）或端口接收分析消息。接收器被排除在所有分析之外。第二个参数是分析选项列表：

exclusive

如果从一个进程对一个端口进行同步调用完成，则调用进程在端口的调用运行期间被认为是不可运行的。调用过程会在通知端口回叫时inactive及之后通知active。

monotonic_timestamp

配置文件消息中的时间戳使用Erlang monotonic time。时间标记（Ts）具有与生成的相同的格式和值erlang:monotonic_time(nanosecond)。

runnable_procs

如果进程被放入运行队列或从运行队列中移除{profile, Pid, State, Mfa, Ts}，则会发送一条消息，ProfilerPid。正在运行的进程在被预占后重新插入到运行队列中，不会触发此消息。

runnable_ports

如果端口被放入运行队列或从运行队列中移除{profile, Port, State, 0, Ts}，则会发送一条消息给ProfilerPid。

scheduler

如果调度程序进入睡眠或唤醒状态{profile, scheduler, Id, State, NoScheds, Ts}，则会发送一条消息给ProfilerPid。

strict_monotonic_timestamp

简档消息中的时间戳由Erlang monotonic time单调递增的整数组成。时间标记（Ts）具有与{erlang:monotonic_time(nanosecond), erlang:unique_integer([monotonic])}生成的相同的格式和值。

timestamp

配置文件消息中的时间戳包括与erlang：now（）返回的格式相同的时间戳（Ts）。 如果没有指定时间戳标志，这也是默认值。 如果通过erlang：trace / 3启用了cpu_timestamp，则在启用标记时间戳时，这也会影响分析邮件中生成的时间戳。

注意

erlang:system_profile 行为可能会在未来版本中发生变化。

erlang：system_time（） - > integer（）

以本地时间单位返回当前的Erlang系统时间。

调用erlang:system_time()等同于erlang:monotonic_time()+erlang:time_offset()。

注意

这一次在一般情况下不是一个单调递增的时间。有关更多信息，请参阅time warp modes用户指南中的文档。

erlang:system_time(Unit) -> integer()

类型

返回Erlang system time转换为Unit作为参数传递的当前值。

调用erlang:system_time(Unit)等同于erlang:convert_time_unit(erlang:system_time(), native, Unit)。

注意

这一次在一般情况下不是一个单调递增的时间。有关更多信息，请参阅time warp modes用户指南中的文档。

term_to_binary(Term) -> ext_binary()

类型

根据Erlang外部术语格式返回编码Term的结果的二进制数据对象。

这可以用于各种目的，例如，以有效的方式向文件中写入术语，或者将Erlang术语发送给分布式Erlang不支持的某种类型的通信通道。

> Bin = term_to_binary（你好）。
<< 131,100,0,5,104,101,108,108,111 >>
> hello = binary_to_term（Bin）。
你好

另见binary_to_term/1。

term_to_binary(Term, Options) -> ext_binary()

类型

返回一个二进制数据对象，该对象是Term根据Erlang外部术语格式进行编码的结果。

如果提供选项压缩，则外部术语格式将被压缩。 从Erlang / OTP R7B的binary_to_term / 1自动识别压缩格式。

压缩级别可以通过赋予选项来指定{compressed, Level}。Level是范围为0..9的整数，其中：

• 0- 不进行压缩（与不提供compressed选项相同）。

• 1 - 花费最少的时间，但可能无法压缩以及更高的水平。

• 6- compressed提供选项时的默认级别。

• 9 - 花费大部分时间并尝试产生较小的结果。在前面的句子中通知“尝试”; 取决于输入项，第9级压缩不是产生比第1级压缩更小的结果。

选项{minor_version, Version}可以用来控制一些编码细节。这个选项是在Erlang / OTP R11B-4中引入的。有效值为Version：

0

浮点数使用文本表示进行编码。此选项对于确保Erlang / OTP R11B-4之前的版本可以解码生成的二进制文件很有用。

该版本使用latin1编码编码可以用latin1字符串表示的原子，而只有不能用latin1表示的原子使用utf8编码。

1

这是Erlang / OTP 17.0的默认设置。它强制该术语中的任何浮点数以更加节省空间且精确的方式进行编码（即以64位IEEE格式进行编码，而不是转换为文本表示）。从Erlang / OTP R11B-4开始，binary_to_term/1可以对此表示进行解码。

该版本使用latin1编码编码可以用latin1字符串表示的原子，而只有不能用latin1表示的原子使用utf8编码。

2

删除latin1原子编码的使用，并无条件地为所有原子使用utf8编码。这将在未来的Erlang / OTP主要版本中更改为默认值。从R16B开始的Erlang / OTP系统可以解码这种表示。

另见binary_to_term/1。

throw(Any) -> no_return()

类型

来自函数的非本地返回。如果在a中评估catch，catch返回值Any。例：

> catch throw({hello, there}).
{hello,there}

失败：nocatch如果没有在捕获中进行评估。

time() -> Time

类型

返回当前时间{Hour, Minute, Second}。

时区和夏令时更正取决于底层操作系统。例：

> time().
{9,42,44}

erlang：time_offset（） - > integer（）

以本地时间单位返回Erlang单调时间和Erlang系统时间之间的当前时间偏移量。 将当前时间偏移添加到Erlang单调时间中可以得到相应的Erlang系统时间。

根据使用情况，时间偏移在操作过程中可能会也可能不会发生变化time warp mode。

注意

时间偏移的变化可以通过不同的过程在稍微不同的时间点观察到。

如果运行系统处于多时间扭曲模式，则当运行系统检测到OS系统时间已更改时，时间偏移会更改。 然而，运行时系统在发生时不会立即检测到它。 检查时间偏移量的任务计划至少每分钟执行一次; 因此，在正常操作下，这种情况会在一分钟内检测到，但在重负载情况下，可能需要较长的时间。

erlang：time_offset（Unit） - > integer（）

类型

返回之间的当前时间偏移量Erlang monotonic time并将其Erlang system time转换为Unit传递的as参数。

与erlang:convert_time_unit(erlang:time_offset(), native, Unit)通常使用Unit的优化调用相同。

erlang：timestamp（） - >时间戳

类型

以格式{MegaSecs，Secs，MicroSecs}返回当前的Erlang系统时间。 这种格式与os：timestamp / 0和不推荐使用的erlang：now / 0相同。 erlang：timestamp（）存在的原因纯粹是为了简化对采用此时间戳格式的现有代码的使用。 当前的Erlang系统时间可以使用erlang：system_time / 1以您选择的时间单位更高效地检索。

该erlang:timestamp()BIF相当于：

timestamp() ->
    ErlangSystemTime = erlang:system_time(microsecond),
    MegaSecs = ErlangSystemTime div 1000000000000,
    Secs = ErlangSystemTime div 1000000 - MegaSecs*1000000,
    MicroSecs = ErlangSystemTime rem 1000000,
    {MegaSecs, Secs, MicroSecs}.

但是，它使用本机实现，不会在堆上构建垃圾，并且性能略好。

注意

这一次在一般情况下不是一个单调递增的时间。有关更多信息，请参阅time warp modes用户指南中的文档。

tl（List） - > term（）

类型

返回列表List的尾部，即列表减去第一个元素，例如：

> tl([geesties, guilies, beasties]).
[guilies, beasties]

允许在警卫测试。

失败：badarg如果List是空列表[]。

erlang：trace（PidPortSpec，How，FlagList） - > integer（）

类型

打开（如果How == true）或关闭（如果How == false）FlagList用于表示的进程或进程的跟踪标志PidPortSpec。

PidPortSpec 是本地进程的进程标识符（pid），端口标识符或以下原子之一：

all所有当前现有的流程和端口以及未来将要创建的所有流程和端口。

processes所有当前现有的流程以及未来将要创建的所有流程。 ports目前所有现有的端口以及将来会创建的所有端口。 existing所有现有的进程和端口。

existing_processes所有现有的流程。

existing_ports所有当前现有的端口。

new所有将在未来创建的进程和端口。

new_processes所有将在未来创建的进程。

new_ports所有将在未来创建的端口。

FlagList可以包含任意数量的以下标志（“消息标签”指的是列表trace messages）：

all

设置除tracer和cpu_timestamp之外的所有跟踪标志，它们的性质与其他标志不同。

send

跟踪发送消息。

消息标签：send和send_to_non_existing_process。

'receive'

跟踪接收消息。

消息标签：'receive'。

call

跟踪某些函数调用。通过调用指定要追踪哪些函数调用erlang:trace_pattern/3。

消息标签：call和return_from。

silent

使用的call跟踪标记。的call，return_from和return_to跟踪如果设置了此标志的消息被禁止，但如果有匹配规范他们正常执行。

无声模式通过执行erlang:trace(_, false, [silent|_])或通过执行该功能的匹配规范来禁止{silent, false}。

该silent跟踪标志有利于建立对许多，甚至在系统中的所有进程痕迹。然后可以使用匹配指定函数激活和禁用轨迹{silent,Bool}，从而高度控制哪些函数具有触发轨迹的参数。

消息标签：call，return_from，和return_to。或者说，没有。

return_to

使用的call跟踪标记。将追踪函数的返回跟踪回调用者。仅适用于与选项追踪功能local来erlang:trace_pattern/3。

语义是跟踪消息在呼叫跟踪函数返回时发送，也就是说，当尾递归调用链结束时。每个尾递归调用链中只发送一条跟踪消息，因此函数调用的尾递归属性在跟踪此标志时保持不变。随时使用call和return_to跟踪可以准确知道进程在任何时间执行哪个功能。

要获取包含函数返回值的跟踪消息，请改为使用{return_trace}匹配规范操作。

消息标签：return_to。

procs

跟踪进程相关的事件。

消息标签：spawn，spawned，exit，register，unregister，link，unlink，getting_linked，和getting_unlinked。

ports

跟踪与端口相关的事件。

消息标签：open，closed，register，unregister，getting_linked，和getting_unlinked。

running

跟踪进程调度。

消息标签：in和out。

exiting

跟踪现有流程的调度。

消息标签：in_exiting，out_exiting，和out_exited。

running_procs

跟踪进程的调度running。但是，此选项还包括进程在端口的上下文内执行而不会自行调度的时间表事件。

消息标签：in和out。

running_ports

跟踪端口的调度。

消息标签：in和out。

garbage_collection

跟踪进程的垃圾回收。

消息标签：gc_minor_start，gc_max_heap_size，和gc_minor_end。

timestamp

包含所有跟踪消息中的时间戳记。时间戳（Ts）与返回的格式erlang:now()相同。

cpu_timestamp

Erlang节点的全局跟踪标志使得使用标志时间戳的所有跟踪时间戳处于CPU时间，而不是挂钟时间。 也就是说，如果启用了monotonic_timestamp或strict_monotonic_timestamp，则不会使用cpu_timestamp。 只允许使用PidPortSpec ==全部。 如果主机OS不支持高分辨率CPU时间测量，trace / 3将以badarg退出。 请注意，大多数操作系统不会跨核心同步此值，因此请准备好使用此选项时可能会倒退。

monotonic_timestamp

包含所有跟踪消息中的Erlang单调时间戳。 时间戳（Ts）与erlang生成的格式和值相同：monotonic_time（纳秒）。 该标志覆盖标志cpu_timestamp。

strict_monotonic_timestamp

包含一个由Erlang单调时间组成的时间戳和所有跟踪消息中单调递增的整数。 时间戳（Ts）与{erlang：monotonic_time（纳秒），erlang：unique_integer（[monotonic]）}所产生的格式和值相同。 该标志覆盖标志cpu_timestamp。

arity

使用的call跟踪标记。{M, F, Arity}被指定而不是{M, F, Args}在调用跟踪消息中。

set_on_spawn

使由跟踪进程创建的任何进程继承其跟踪标志（包括标志）set_on_spawn。

set_on_first_spawn

使被跟踪进程创建的第一个进程继承其跟踪标志，不包括标志set_on_first_spawn。

set_on_link

使跟踪进程链接的任何进程都会继承其跟踪标志（包括标志）set_on_link。

set_on_first_link

使跟踪进程链接的第一个进程继承其跟踪标志（不包括标志）set_on_first_link。

{tracer, Tracer}

指定发送跟踪消息的位置。Tracer必须是本地进程的进程标识符或本地端口的端口标识符。

{tracer, TracerModule, TracerState}

指定要调用跟踪器模块而不是发送跟踪消息。跟踪器模块可以忽略或更改跟踪消息。有关如何编写示踪模块的更多详细信息，请参阅erl_tracer(3)。

如果没有 tracer指定，则调用进程接收所有跟踪消息。

set_on_first_link与set_on_link的结合效果与set_on_first_link单独相同。 同样适用于set_on_spawn和set_on_first_spawn。

跟踪进程接收以下列表中描述的跟踪消息。Pid是跟踪过程中发生跟踪事件的过程标识符。第三个元组元素是消息标签。

如果指定了标志时间戳，strict_monotonic_timestamp或monotonic_timestamp，则第一个元组元素是trace_ts，而时间戳将作为消息元组中最后一个额外元素添加。 如果传递多个时间戳标志，则时间戳优先于strict_monotonic_timestamp，而该优先级优先于monotonic_timestamp。 所有时间标记都会被记住，所以如果两个时间标记都被通过，并且以后具有最高优先级的时间被禁用，另一个将变为活动状态。

跟踪消息：

{trace, PidPort, send, Msg, To}

在PidPort发送消息时Msg处理To。

{trace, PidPort, send_to_non_existing_process, Msg, To}

何时PidPort向Msg不存在的进程发送消息To。

{trace, PidPort, 'receive', Msg}

当PidPort收到消息Msg。如果Msg设置为超时，接收语句可能已超时，或者进程收到带有有效负载的消息timeout。

{trace, Pid, call, {M, F, Args}}

当Pid调用追踪函数时。调用的返回值永远不会被提供，只有调用及其参数。

跟踪标志arity可用于更改此消息的内容，以便Arity指定而不是Args。

{trace, Pid, return_to, {M, F, Arity}}

当Pid返回到指定的功能。如果两个标志此跟踪消息发送call和return_to设置，并在功能设置上要跟踪本地函数调用。该消息仅在从一个尾递归函数调用链返回时发送，其中至少有一个调用生成了call跟踪消息（即匹配的函数匹配规范，而{message, false}不是一个操作）。

{trace, Pid, return_from, {M, F, Arity}, ReturnValue}

当Pid返回从指定的函数。如果call设置了标志，则会发送此跟踪消息，并且该函数与某个return_trace或某个exception_trace操作具有匹配规范。

{trace, Pid, exception_from, {M, F, Arity}, {Class, Value}}

当Pid由于异常而退出指定功能时。 如果设置了标志调用，则会发送此跟踪消息，并且该函数具有带有exception_trace操作的匹配规范。

{trace, Pid, spawn, Pid2, {M, F, Args}}

当以指定的函数调用Pid产生一个新进程Pid2作为入口点时。

Args 应该是参数列表，但如果菌种错误，可以是任何术语。

{trace, Pid, spawned, Pid2, {M, F, Args}}

当Pid被Pid2指定的函数调用作为入口点进程产生时。

Args 应该是参数列表，但如果菌种错误，可以是任何术语。

{trace, Pid, exit, Reason}

当Pid有理由退出时。

{trace, PidPort, register, RegName}

当PidPort获取名称RegName注册。

{trace, PidPort, unregister, RegName}

当PidPort名称RegName取消注册时。这是在注册的进程或端口退出时自动完成的。

{trace, Pid, link, Pid2}

当Pid链接到一个过程Pid2。

{trace, Pid, unlink, Pid2}

当Pid去除链接Pid2。

{trace, PidPort, getting_linked, Pid2}

当PidPort被链接到一个过程Pid2。

{trace, PidPort, getting_unlinked, Pid2}

当PidPort被解除链接Pid2。

{trace, Pid, exit, Reason}

当Pid有理由Reason退出时。

{trace, Port, open, Pid, Driver}

当Pid使用正在运行的驱动程序打开一个新的端口端口。

Driver 是作为原子的驱动程序的名称。

{trace, Port, closed, Reason}

当Port关闭Reason时。

{trace, Pid, in | in_exiting, {M, F, Arity} | 0}

Pid计划何时运行。该过程在功能中运行{M, F, Arity}。在一些罕见的情况下，当前函数不能确定，那么最后一个元素是0。

{trace, Pid, out | out_exiting | out_exited, {M, F, Arity} | 0}

当Pid安排好。该过程在函数{M，F，Arity}中运行。在一些罕见的情况下，当前函数不能确定，那么最后一个元素是0。

{trace, Port, in, Command | 0}

当Port计划运行。Command是端口将执行的第一件事，但它可以在被排除之前运行几个命令。在一些罕见的情况下，当前函数不能确定，那么最后一个元素是0。

可能的命令是call，close，command，connect，control，flush，info，link，open，和unlink。

{trace, Port, out, Command | 0}

当Port安排好。最后一个命令是Command。在一些罕见的情况下，当前函数不能确定，那么最后一个元素是0。Command可以包含与。相同的命令in

{trace, Pid, gc_minor_start, Info}

当新的垃圾收集即将开始时发送。Info是两元素元组的列表，其中第一个元素是一个键，第二个元素是该值。不要依赖任何元组的顺序。以下键被定义：

heap_size堆的使用部分的大小。heap_block_size用于存储堆和堆栈的内存块的大小。old_heap_size旧堆的旧部分的大小。old_heap_block_size用于存储旧堆的内存块的大小。stack_size堆栈的大小。recent_size在先前的垃圾收集中存活的数据的大小。mbuf_size与进程关联的消息缓冲区的组合大小。bin_vheap_size从进程堆中引用的唯一堆外二进制文件的总大小。bin_vheap_block_size在进行垃圾回收之前，进程中虚拟堆中允许的二进制文件的总大小。bin_old_vheap_size从进程旧堆引用的唯一堆外二进制文件的总大小。bin_old_vheap_block_size 在进行垃圾回收之前，进程中虚拟旧堆中允许的二进制文件的总大小。

所有的大小都是文字。

{trace, Pid, gc_max_heap_size, Info}

max_heap_size垃圾收集期间到达时发送。Info包含与消息中相同类型的列表gc_start，但大小反映了触发max_heap_size达到的大小。

{trace, Pid, gc_minor_end, Info}

新的垃圾收集结束后发送。Info包含与消息中相同类型的列表gc_minor_start，但大小反映垃圾收集后的新大小。

{trace, Pid, gc_major_start, Info}

当fullsweep垃圾收集即将开始时发送。Info包含与消息gc_minor_start中相同的列表。

{trace, Pid, gc_major_end, Info}

fullsweep垃圾收集完成时发送。Info包含与消息中相同的列表gc_minor_start，但大小反映了全扫描垃圾回收后的新大小。

如果跟踪进程/端口死亡或者跟踪器模块返回remove，则会自动删除这些标志。

每个进程只能由一个追踪器追踪。因此，追踪已经追踪的进程的尝试失败。

返回一个数字，指示匹配的进程的数量PidPortSpec。如果PidPortSpec是进程标识符，则返回值为1。如果PidPortSpec是all或existing，返回值是正在运行的进程的数量。如果PidPortSpec是new，返回值是0。

失败：badarg如果指定的参数不受支持。例如，cpu_timestamp在所有平台上都不支持。

erlang:trace_delivered(Tracee) -> Ref

类型

与系统中的其他事件相比，跟踪消息（由erlang：trace / 3，seq_trace（3）或erlang：system_profile / 2生成）的传递在时间线上错位。 如果您知道Tracee已经在其执行过程中通过了某个特定点，并且您想知道至少与此时事件相对应的所有跟踪消息何时到达了跟踪器，请使用erlang：trace_delivered（Tracee）。

如果保证所有跟踪消息都被传递给跟踪器，直到Tracee达到调用时达到的点erlang:trace_delivered(Tracee)，则向{trace_delivered, Tracee, Ref}消息的调用者发送消息erlang:trace_delivered(Tracee)。

请注意，消息trace_delivered并没有暗示跟踪消息已经交付。相反，它意味着所有要交付的跟踪消息都已交付。如果Tracee不是，并且没有被某人追踪，那不是一个错误，但如果是这种情况，那么在trace_delivered消息到达时没有跟踪消息被传递。

请注意，Tracee必须引用当前或先前存在于erlang:trace_delivered(Tracee)驻留在相同节点上的进程。特殊Tracee原子all表示当前在节点中被跟踪的所有进程。

与跟踪器模块一起使用时，跟踪回调中发送的任何消息都会保证在发送trace_delivered消息之前到达其收件人。

例如：进程A是Tracee，端口B是跟踪器，进程C是B的端口所有者.C在A退出时想要关闭B. 为确保跟踪未被截断，C在退出时可以调用erlang：trace_delivered（A），并在关闭B之前等待消息{trace_delivered，A，Ref}。

失败：badarg如果Tracee未在与erlang:trace_delivered(Tracee)驻留的调用方相同的节点上引用进程（死或活）。

erlang:trace_info(PidPortFuncEvent, Item) -> Res

类型

'$ 1'| '$ 2'| '$ 3'| ...的近似值

返回有关端口，进程，函数或事件的跟踪信息。

要获得关于一个端口或过程的信息，PidPortFuncEvent将是一个进程标识符（PID），端口标识符，或原子中的一个new，new_processes或new_ports。原子new或new_processes意味着要创建的进程的默认跟踪状态被返回。该atom new_ports表示将返回要创建的端口的默认跟踪状态。

有效Item的港口和流程：

flags

返回原子列表，指示为该过程启用了哪种跟踪。：如果没有痕迹启用，并且以下原子的一种或多种微量是否启用该列表是空的send，'receive'，set_on_spawn，call，return_to，procs，ports，set_on_first_spawn，set_on_link，running，running_procs，running_ports，silent，exiting，monotonic_timestamp，strict_monotonic_timestamp，garbage_collection，timestamp，和arity。顺序是任意的。

tracer

返回包含tracer模块和tracer状态的进程，端口或元组的跟踪标识符，以此跟踪此进程。如果这个过程没有跟踪，返回值是[]。

要获得关于某个函数的信息，PidPortFuncEvent应该是三元元组{Module，Function，Arity}或原子on_load。 不允许使用通配符。 如果函数不存在，则返回undefined;如果函数未被跟踪，则返回false。 如果PidPortFuncEvent是on_load，则返回的信息是指将加载的代码的默认值。

Item功能有效：

traced

如果此函数追踪全局函数调用，则返回全局，如果此函数在本地函数调用（即本地函数调用和全局函数调用）上追踪，则为本地;如果未追踪本地或全局函数调用，则返回false。

match_spec

返回此函数的匹配规范（如果有）。如果该函数是本地或全局跟踪的，但没有定义匹配规范，则返回值为[]。

meta

返回此函数的元痕迹跟踪器进程，端口或跟踪模块（如果有）。如果该函数不是元跟踪的，则返回值为false。如果函数是元跟踪的，但是一旦检测到跟踪程序过程无效，则返回值为[]。

meta_match_spec

返回此函数的元痕迹匹配规范（如果有）。如果该函数是元跟踪的，但没有定义匹配规范，则返回值为[]。

call_count

返回此函数的调用计数值，如果调用计数跟踪处于活动状态，则返回伪函数on_load的值true。 否则返回false。

另见erlang:trace_pattern/3。

call_time

返回此函数的调用时间值，如果调用时间跟踪处于活动状态，则返回伪函数on_load的true。 否则返回false。 返回的调用时间值[{Pid，Count，S，Us}]是执行函数及其特定计数器的每个进程的列表。

另见erlang:trace_pattern/3。

all

返回包含{Item, Value}所有其他项目的元组的列表，false

如果没有此功能的跟踪处于活动状态，则返回该列表。

要获得有关某个事件的信息，PidPortFuncEvent应该是其中的一个原子send或'receive'。

一个有效Item的事件存在：

match_spec

返回此事件的匹配规范，如果它有一个，或者true没有设置匹配规范。

返回值是{Item，Value}，其中Value是前面所述的请求信息。 如果指定了死进程的pid或者不存在函数的名称，则值是未定义的。

Erlang：trace_pattern（MFA，MatchSpec） - > integer（）> = 0

类型

'$ 1'| '$ 2'| '$ 3'| ...的近似值

同erlang:trace_pattern(Event, MatchSpec, [])，为了向后兼容而保留。

Erlang：trace_pattern（MFA :: send，MatchSpec，FlagList :: []） - >

integer() >= 0

类型

'$ 1'| '$ 2'| '$ 3'| ...的近似值

设置消息发送的跟踪模式。必须结合使用erlang:trace/3才能send为一个或多个进程设置跟踪标志。默认情况下，send跟踪的进程发送的所有消息都会被跟踪。为了限制基于消息内容的跟踪发送事件，使用发送者和/或接收者erlang:trace_pattern/3。

参数MatchSpec可以采取以下形式：

MatchSpecList

匹配规范的列表。匹配在列表上完成[Receiver, Msg]。Receiver是接收方的进程或端口标识，Msg是消息术语。发送过程的pid可以通过保护功能进行访问self/0。一个空的列表与true。有关更多信息，请参阅Match Specifications in Erlang用户指南中的部分。

true

对所有发送的消息启用跟踪（来自send跟踪的进程）。任何匹配规范都将被删除。这是默认设置。

false

禁用所有发送的消息的跟踪。任何匹配规范都将被删除。

参数FlagList必须为[]用于发送跟踪。

返回值总是1。

例子：

只跟踪特定进程的消息Pid：

> erlang:trace_pattern(send, [{[Pid, '_'],[],[]}], []).
1

只跟踪匹配的消息{reply, _}：

> erlang:trace_pattern(send, [{['_', {reply,'_'}],[],[]}], []).
1

仅跟踪发送给发件人本身的邮件：

> erlang:trace_pattern(send, [{['$1', '_'],[{'=:=','$1',{self}}],[]}], []).
1

仅跟踪发送到其他节点的消息：

> erlang：trace_pattern（send，[{['$ 1'，'_']，[{'= / ='，{node，'$ 1'}，{node}}]，[]}]，[]）。
1

注意

send跟踪的匹配规范可以使用除所有警卫和身体功能caller。

erlang：trace_pattern（MFA ::'receive'，MatchSpec，FlagList :: []） - >

integer（）> = 0

类型

'$ 1'| '$ 2'| '$ 3'| ...的近似值

设置消息接收的跟踪模式。必须结合使用erlang:trace/3才能'receive'为一个或多个进程设置跟踪标志。默认情况下，'receive'跟踪的进程收到的所有消息都会被跟踪。为了限制基于消息内容的跟踪接收事件，发送者和/或接收者使用erlang:trace_pattern/3。

论据MatchSpec可以采取以下形式：

MatchSpecList

匹配规范的列表。匹配在列表上完成[Node, Sender, Msg]。Node是发件人的节点名称。Sender是发件人的进程或端口标识，或者是undefined发件人未知的原子（远程发件人可能是这种情况）。Msg是消息术语。接收过程的pid可以通过保护功能进行访问self/0。一个空的列表与true。有关更多信息，请参阅Match Specifications in Erlang用户指南中的部分。

true

对所有收到的消息启用跟踪（对'receive'跟踪的过程）。任何匹配规范都将被删除。这是默认设置。

false

禁用所有收到的消息的跟踪。任何匹配规范都将被删除。

参数FlagList必须[]用于接收跟踪。

返回值总是1。

例子：

仅跟踪特定进程的消息Pid：

> erlang:trace_pattern('receive', [{['_',Pid, '_'],[],[]}], []).
1

只跟踪匹配的消息{reply, _}：

> erlang:trace_pattern('receive', [{['_','_', {reply,'_'}],[],[]}], []).
1

仅跟踪来自其他节点的消息：

> erlang:trace_pattern('receive', [{['$1', '_', '_'],[{'=/=','$1',{node}}],[]}], []).
1

注意

对于一场匹配规格'receive'跟踪可以使用所有后卫和身体功能除了caller，is_seq_trace，get_seq_token，set_seq_token，enable_trace，disable_trace，trace，silent，和process_dump。

erlang：trace_pattern（MFA，MatchSpec，FlagList） - >

integer（）> = 0

类型

'$ 1'| '$ 2'| '$ 3'| ...的近似值

启用或禁用一个或多个功能的调用跟踪。必须结合使用erlang:trace/3才能call为一个或多个进程设置跟踪标志。

从概念上讲，调用跟踪的工作原理如下。在Erlang虚拟机中，需要跟踪一组进程和一组函数。如果跟踪进程调用跟踪函数，则执行跟踪操作。否则，没有任何反应。

要将一个或多个进程添加到一组被跟踪进程或将其删除，请使用erlang:trace/3。

要添加或删除功能到一组被跟踪的功能，请使用erlang:trace_pattern/3。

BIF erlang:trace_pattern/3还可以将匹配规格添加到功能。匹配规范包含函数参数必须匹配的模式，必须评估的警戒表达式true以及要执行的操作。默认操作是发送跟踪消息。如果模式不匹配或防护失败，则不执行该操作。

参数MFA是一个元组，例如{Module, Function, Arity}，或原子on_load（如下所述）。它可以是模块，函数和函数的参数（或任何模块中的BIF）。原子'_'可以通过以下任何方式用作通配符：

{Module,Function,'_'}

Function在模块中命名的任何模块的所有功能Module。

{Module,'_','_'}

模块中的所有功能Module。

{'_','_','_'}

所有加载模块中的所有功能。

其他组合，例如{Module,'_',Arity}，是不允许的。只有选项local处于，本地函数才匹配通配符FlagList。

如果参数MFA是原子on_load，则在新加载的所有模块上使用匹配规范和标志列表。

论据MatchSpec可以采取以下形式：

false

禁用匹配功能的跟踪。任何匹配规范都将被删除。

true

启用匹配功能的跟踪。任何匹配规范都将被删除。

MatchSpecList

匹配规范的列表。一个空的列表相当于true。有关匹配规格的说明，请参见Match Specifications in Erlang用户指南中的部分。

restart

对于FlagList选项call_count和call_time：重新启动现有的计数器。其他FlagList选项的行为未定义。

pause

对于FlagList选项call_count和call_time：暂停现有的计数器。其他FlagList选项的行为未定义。

参数FlagList是一个选项列表。以下是有效的选项：

global

打开或关闭全局函数调用的呼叫跟踪（即显式指定模块的调用）。只有导出的函数匹配并且只有全局调用会生成跟踪消息 这是默认设置。

local

打开或关闭所有类型函数调用的调用跟踪。只要调用任何指定的函数，就会发送跟踪消息，无论它们是如何被调用的。如果return_to为进程设置了标志，return_to当此函数返回给调用者时也会发送一条消息。

meta | {meta, Pid} | {meta, TracerModule, TracerState}

打开或关闭所有类型函数调用的元跟踪。只要调用任何指定的函数，跟踪消息就会发送给跟踪器。如果未指定跟踪器，则将self()其用作默认跟踪器流程。

元跟踪跟踪所有进程，不关心由设置的进程跟踪标志erlang:trace/3，跟踪标志被固定到[call, timestamp]。

匹配规范函数{return_trace}与元痕迹一起工作，并将其跟踪消息发送给同一个跟踪器。

call_count

为所有类型的函数调用启动（MatchSpec == true）或停止（MatchSpec == false）调用计数跟踪。对于每个函数，在任何进程中调用函数时都会递增计数器。无需激活进程跟踪标志。

如果呼叫计数跟踪在运行时开始，则计数从零重新开始。要暂停运行计数器，请使用MatchSpec == pause。暂停和运行计数器可以从零开始重新启动MatchSpec == restart。

要读取计数器值，请使用erlang:trace_info/2。

call_time

开始（MatchSpec == true）或停止（MatchSpec == false）调用所有类型的函数调用的时间跟踪。对于每个函数，当函数被调用时计数器增加。在函数中花费的时间在另外两个计数器中累积，秒和微秒。计数器存储每个呼叫跟踪过程。

如果在运行时开始呼叫时间跟踪，则计数和时间从零重新开始。要暂停运行计数器，请使用MatchSpec == pause。暂停和运行计数器可以从零开始重新启动MatchSpec == restart。

要读取计数器值，请使用erlang:trace_info/2。

选项global和local相互排斥的，并且global是默认的（如果没有指定任何选项）。选项call_count和meta执行一种本地跟踪，并且不能与global组合。一个函数可以被全局或本地跟踪。如果为一组函数指定全局跟踪，则会禁用匹配的本地函数集的本地，元，调用时间和调用计数跟踪，反之亦然。

禁用跟踪时，该选项必须与功能上设置的跟踪类型相匹配。也就是说，本地跟踪必须通过选项local和带选项的全局跟踪global（或无选项）来禁用，依此类推。

部分匹配规范列表不能直接更改。如果函数具有匹配规范，则可以用新规则替换它。要更改现有的匹配规范，请使用BIF erlang:trace_info/2检索现有的匹配规范。

返回与参数匹配的函数的数量MFA。如果没有匹配，这个值为零。

trunc（Number） - > integer（）

类型

通过截断返回整数Number，例如：

> trunc（5.5）。
5

允许在when模式匹配下使用

tuple_size（Tuple） - > integer（）> = 0

类型

返回一个整数，它是元素的个数Tuple，例如：

> tuple_size（{morni，mulle，bwange}）。
3

允许在警卫测试。

tuple_to_list（Tuple） - > term（）

类型

返回对应的列表Tuple。Tuple可以包含任何Erlang条款。例：

> tuple_to_list({share, {'Ericsson_B', 163}}).
[share,{'Ericsson_B',163}]

erlang:unique_integer() -> integer()

生成并返回一个integer unique on current runtime system instance。跟调用erlang:unique_integer([])一样。

erlang:unique_integer(ModifierList) -> integer()

类型

生成并返回一个integer unique on current runtime system instance。该整数是唯一的，因为此BIF使用相同的修改器集，在当前运行时系统实例上不会多次返回相同的整数。每个整数值当然可以用其他方法构造。

默认情况下，当[]传递ModifierList时，可以返回负整数和正整数。这可以尽可能地使用不需要堆内存分配的整数范围。默认情况下，返回的整数也只能保证是唯一的，也就是说，返回的整数可以小于或大于以前返回的整数。

Modifiers:

正

只返回正整数。

请注意，通过传递positive修饰符，您将更快地获得堆整数（bignums）。

单调

返回strictly monotonically increasing与创建时间相对应的整数。也就是说，返回的整数总是大于当前运行时系统实例中以前返回的整数。

这些值可用于确定运行时系统实例上的事件之间的顺序。 也就是说，如果X = erlang：unique_integer（[monotonic]）和Y = erlang：unique_integer（[monotonic]）由同一个运行时系统实例和X <Y上的不同进程（或同一进程）执行， X是在Y之前创建的。

警告

严格单调递增的值本质上是相当昂贵的，并且产生不好的规模。这是因为这些值需要在CPU内核之间同步。也就是说，monotonic除非你确实需要严格单调递增的值，否则不要通过修饰符。

所有有效的Modifiers可以合并。重复（有效）Modifiers ModifierList被忽略。

注意

通过erlang:unique_integer/1使用不同的Modifiers 集合返回的整数集合将重叠。例如，通过重复调用unique_integer([monotonic])，unique_integer([positive, monotonic])您最终会看到两个调用返回的一些整数。

失败：

badarg 如果ModifierList不是正确的列表。

badarg 如果Modifier不是有效的修饰符。

erlang:universaltime() -> DateTime

类型

如果基础操作系统支持，则按照协调世界时（UTC）格式{{Year，Month，Day}，{Hour，Minute，Second}}}返回当前日期和时间。 否则erlang：universaltime（）相当于erlang：localtime（）。 例：

> erlang:universaltime().
{{1996,11,6},{14,18,43}}

erlang:universaltime_to_localtime(Universaltime) -> Localtime

类型

{{Year, Month, Day}, {Hour, Minute, Second}}如果受基础操作系统支持，则将世界协调时间（UTC）日期和时间转换为本地日期和时间。否则，没有转换完成，并Universaltime返回。例：

> erlang:universaltime_to_localtime({{1996,11,6},{14,18,43}}).
{{1996,11,7},{15,18,43}}

失败：badarg

如果 Universaltime表示无效的日期和时间。

unlink(Id) -> true

类型

删除调用进程和参考的进程或端口之间的链接（如果有的话）

返回true并且不会失败，即使没有链接Id或Id不存在也是如此。

一旦unlink(Id)返回，将保证呼叫方和实体之间的链接Id将来不会对调用方产生影响（除非再次设置链接）。如果主叫方陷入退出状态，{'EXIT', Id, _}来自该链接的消息可能在呼叫之前放入了主叫方的消息队列中。

请注意，该{'EXIT', Id, _}消息可能是链接的结果，但也可能是Id调用的结果exit/2。因此，在调用之后退出时清理消息队列可能是合适的unlink(Id)，如下所示：

unlink(Id),
receive
    {'EXIT', Id, _} ->
        true
after 0 ->
        true
end

注意

在Erlang / OTP R11B（ERTS 5.5）unlink/1完全异步运行之前，也就是说，链接处于活动状态，直到“取消链接信号”到达链接实体。这有一个不良影响，因为你永远不知道你什么时候保证不会受到链接的影响。

当前行为可以被看作是两个联合操作：异步发送一个“unlink信号”给链接的实体，并忽略任何未来的链接结果。

unregister(RegName) -> true

类型

删除RegName与进程标识符或端口标识符关联的注册名称，例如：

> unregister(db).
true

建议用户不要注销系统进程。

失败：badarg

如果RegName不是注册名称。

whereis(RegName) -> pid() | port() | undefined

类型

用注册名称返回进程标识符或端口标识符RegName。如果名称未注册，则返回undefined。例：

> whereis(db).
<0.43.0>

erlang:yield() -> true

自愿让其他进程（如果有的话）有机会执行。使用此功能与receive after 1 -> ok end类似，但yield()速度更快。

警告

很少或根本不需要使用此BIF，尤其是在SMP模拟器中，因为其他进程有机会在另一个调度器线程中运行。如果没有彻底掌握调度程序的工作原理，使用此BIF可能会导致性能下降。