模块 Process

模块 Process 代表底层操作系统中的一个进程。它的方法支持管理当前进程及其子进程。

进程创建¶ ↑

以下每个方法都在一个新的进程或子 shell 中执行给定的命令，或者在新的进程和/或子 shell 中执行多个命令。进程或子 shell 的选择取决于命令的形式；请参阅参数 command_line 或 exe_path。

Process.spawn, Kernel#spawn: 执行命令；返回新的 pid 而不等待完成。
Process.exec: 通过执行命令替换当前进程。

此外

方法 Kernel#system 在子 shell 中执行给定的命令行（字符串）；返回 true、false 或 nil。
方法 Kernel#‘ 在子 shell 中执行给定的命令行（字符串）；返回其 $stdout 字符串。
模块 Open3 支持创建子进程，并访问其 $stdin、$stdout 和 $stderr 流。

执行环境¶ ↑

可选的领先参数 env 是一个名称/值对的哈希表，其中每个名称都是一个字符串，每个值都是一个字符串或 nil；每个名称/值对都会添加到新进程中的 ENV 中。

Process.spawn(                'ruby -e "p ENV[\"Foo\"]"')
Process.spawn({'Foo' => '0'}, 'ruby -e "p ENV[\"Foo\"]"')

输出

"0"

效果通常类似于使用参数 env 调用 ENV#update，其中每个命名的环境变量都会被创建或更新（如果值为非 nil），或删除（如果值为 nil）。

但是，如果新进程失败，调用进程的一些修改可能会保留。例如，不会恢复硬资源限制。

参数 `command_line` 或 `exe_path`¶ ↑

必需的字符串参数是以下之一

command_line 如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
exe_path 否则。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头，以特殊内置函数开头，或包含元字符

system('if true; then echo "Foo"; fi')          # => true  # Shell reserved word.
system('echo')                                  # => true  # Built-in.
system('date > /tmp/date.tmp')                  # => true  # Contains meta character.
system('date > /nop/date.tmp')                  # => false
system('date > /nop/date.tmp', exception: true) # Raises RuntimeError.

命令行还可以包含命令的参数和选项

system('echo "Foo"') # => true

输出

Foo

有关 shell 的详细信息，请参阅执行 shell。

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个包含要调用的可执行文件的路径和用作执行进程名称的字符串的 2 元素数组。

示例

system('/usr/bin/date') # => true # Path to date on Unix-style system.
system('foo')           # => nil  # Command failed.

输出

Mon Aug 28 11:43:10 AM CDT 2023

执行选项¶ ↑

可选的尾随参数 options 是一个执行选项的哈希表。

工作目录 (`:chdir`)¶ ↑

默认情况下，新进程的工作目录与当前进程的工作目录相同

Dir.chdir('/var')
Process.spawn('ruby -e "puts Dir.pwd"')

输出

/var

使用选项 :chdir 设置新进程的工作目录

Process.spawn('ruby -e "puts Dir.pwd"', {chdir: '/tmp'})

输出

/tmp

当前进程的工作目录不会更改

Dir.pwd # => "/var"

文件重定向（文件描述符）¶ ↑

在新进程中使用执行选项进行文件重定向。

此类选项的键可以是整数文件描述符 (fd)，指定一个源，或者是一个 fd 数组，指定多个源。

整数源 fd 可以指定为

n：指定文件描述符 n。

以下是一些 fd 的简写符号

:in：指定文件描述符 0 (STDIN)。
:out：指定文件描述符 1 (STDOUT)。
:err：指定文件描述符 2 (STDERR)。

与源一起给出的值是以下之一

n：重定向到父进程中的 fd n。
filepath：通过 open(filepath, mode, 0644) 从文件 filepath 重定向或到文件 filepath，其中 mode 为源 :in 的 'r'，或源 :out 或 :err 的 'w'。
[filepath]：通过 open(filepath, 'r', 0644) 从文件 filepath 重定向。
[filepath, mode]：通过 open(filepath, mode, 0644) 从文件 filepath 重定向或到文件 filepath。
[filepath, mode, perm]：通过 open(filepath, mode, perm) 从文件 filepath 重定向或到文件 filepath。
[:child, fd]：重定向到重定向的 fd。
:close：在子进程中关闭文件描述符。

参见访问模式和文件权限。

环境变量 (`:unsetenv_others`)¶ ↑

默认情况下，新进程会继承父进程的环境变量；使用执行选项键 :unsetenv_others 并将值设置为 true 以清除新进程中的环境变量。

执行选项 env 指定的任何更改将在新进程继承或清除其环境变量后进行；参见执行环境。

文件创建访问 (`:umask`)¶ ↑

使用执行选项:umask设置新进程的文件创建访问权限；请参阅访问模式

command = 'ruby -e "puts sprintf(\"0%o\", File.umask)"'
options = {:umask => 0644}
Process.spawn(command, options)

输出

进程组 (`:pgroup` 和 `:new_pgroup`)¶ ↑

默认情况下，新进程属于与父进程相同的进程组。

要指定不同的进程组，请使用执行选项:pgroup，并使用以下值之一

true：为新进程创建一个新的进程组。
pgid：在 ID 为 pgid 的进程组中创建新进程。

仅在 Windows 上，使用执行选项:new_pgroup，并使用值true为新进程创建一个新的进程组。

资源限制¶ ↑

使用执行选项设置资源限制。

这些选项的键是形式为:rlimit_resource_name的符号，其中resource_name是方法Process.setrlimit中描述的字符串资源名称的小写形式。例如，键:rlimit_cpu对应于资源限制'CPU'。

此类键的值之一是

一个整数，指定当前和最大限制。
一个包含两个整数的数组，指定当前和最大限制。

文件描述符继承¶ ↑

默认情况下，新进程从父进程继承文件描述符。

使用执行选项:close_others => true通过关闭未重定向的非标准 fd（3 及更大）来修改该继承。

执行 Shell¶ ↑

在类 Unix 系统上，调用的 shell 是/bin/sh；否则，调用的 shell 由环境变量ENV['RUBYSHELL']（如果定义）或ENV['COMSPEC']（否则）确定。

除了COMSPEC情况外，整个字符串command_line作为参数传递给shell 选项 -c。

shell 对命令行执行正常的 shell 扩展

spawn('echo C*') # => 799139
Process.wait     # => 799139

输出

CONTRIBUTING.md COPYING COPYING.ja

这里有什么¶ ↑

当前进程获取器¶ ↑

::argv0: 返回进程名称，以冻结字符串形式。
::egid: 返回有效组 ID。
::euid: 返回有效用户 ID。
::getpgrp: 返回进程组 ID。
::getrlimit: 返回资源限制。
::gid: 返回（真实）组 ID。
::pid: 返回进程 ID。
::ppid: 返回父进程的进程 ID。
::uid: 返回（真实）用户 ID。

当前进程设置器¶ ↑

::egid=: 设置有效组 ID。
::euid=: 设置有效用户 ID。
::gid=: 设置（真实）组 ID。
::setproctitle: 设置进程标题。
::setpgrp: 将进程的进程组 ID 设置为零。
::setrlimit: 设置资源限制。
::setsid: 将进程建立为新的会话和进程组领导者，没有控制终端。
::uid=: 设置用户 ID。

当前进程执行¶ ↑

::abort: 立即终止进程。
::daemon: 将进程与其控制终端分离，并作为系统守护进程在后台继续运行。
::exec: 通过运行给定的外部命令来替换进程。
::exit: 通过引发异常 SystemExit（可以捕获）来启动进程终止。
::exit!: 立即退出进程。
::warmup: 通知 Ruby 虚拟机应用程序的引导序列已完成，并且 VM 可以开始优化应用程序。

子进程¶ ↑

::detach: 防止子进程变成僵尸进程。
::fork: 创建子进程。
::kill: 向进程发送给定信号。
::spawn: 创建子进程。
::wait, ::waitpid: 等待子进程退出；返回其进程 ID。
::wait2, ::waitpid2: 等待子进程退出；返回其进程 ID 和状态。
::waitall: 等待所有子进程退出；返回它们的进程 ID 和状态。

进程组¶ ↑

::getpgid: 返回进程的进程组 ID。
::getpriority: 返回进程、进程组或用户的调度优先级。
::getsid: 返回进程的会话 ID。
::groups: 返回此进程的补充组访问列表中的组 ID 数组。
::groups=: 将补充组访问列表设置为给定的组 ID 数组。
::initgroups: 初始化补充组访问列表。
::last_status: 返回当前线程中最后执行的子进程的状态。
::maxgroups: 返回补充组访问列表中允许的最大组 ID 数。
::maxgroups=: 设置补充组访问列表中允许的最大组 ID 数。
::setpgid: 设置进程的进程组 ID。
::setpriority: 设置进程、进程组或用户的调度优先级。

计时¶ ↑

::clock_getres: 返回系统时钟的分辨率。
::clock_gettime: 返回系统时钟的时间。
::times: 返回一个 Process::Tms 对象，其中包含当前进程及其子进程的时间。

常量

CLOCK_BOOTTIME

参见 Process.clock_gettime

CLOCK_BOOTTIME_ALARM

参见 Process.clock_gettime

CLOCK_MONOTONIC

参见 Process.clock_gettime

CLOCK_MONOTONIC_COARSE

参见 Process.clock_gettime

CLOCK_MONOTONIC_FAST

参见 Process.clock_gettime

CLOCK_MONOTONIC_PRECISE

参见 Process.clock_gettime

CLOCK_MONOTONIC_RAW

参见 Process.clock_gettime

CLOCK_MONOTONIC_RAW_APPROX

参见 Process.clock_gettime

CLOCK_PROCESS_CPUTIME_ID

参见 Process.clock_gettime

CLOCK_PROF

参见 Process.clock_gettime

CLOCK_REALTIME

参见 Process.clock_gettime

CLOCK_REALTIME_ALARM

参见 Process.clock_gettime

CLOCK_REALTIME_COARSE

参见 Process.clock_gettime

CLOCK_REALTIME_FAST

参见 Process.clock_gettime

CLOCK_REALTIME_PRECISE

参见 Process.clock_gettime

CLOCK_SECOND

参见 Process.clock_gettime

CLOCK_TAI

参见 Process.clock_gettime

CLOCK_THREAD_CPUTIME_ID

参见 Process.clock_gettime

CLOCK_UPTIME

参见 Process.clock_gettime

CLOCK_UPTIME_FAST

参见 Process.clock_gettime

CLOCK_UPTIME_PRECISE

参见 Process.clock_gettime

CLOCK_UPTIME_RAW

参见 Process.clock_gettime

CLOCK_UPTIME_RAW_APPROX

参见 Process.clock_gettime

CLOCK_VIRTUAL

参见 Process.clock_gettime

PRIO_PGRP

参见 Process.setpriority

PRIO_PROCESS

参见 Process.setpriority

PRIO_USER

参见 Process.setpriority

RLIMIT_AS

进程虚拟内存（地址空间）的最大大小（以字节为单位）。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_CORE

核心文件最大大小。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_CPU

CPU 时间限制（以秒为单位）。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_DATA

进程数据段的最大大小。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_FSIZE

进程可以创建的文件的最大大小。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_MEMLOCK

可以锁定到 RAM 的内存字节数的最大值。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_MSGQUEUE

指定调用进程的真实用户 ID 可以为 POSIX 消息队列分配的字节数限制。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_NICE

指定进程 nice 值可以提高到的上限。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_NOFILE

指定此进程可以打开的最大文件描述符号加 1 的值。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_NPROC

调用进程的真实用户 ID 可以创建的进程的最大数量。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_NPTS

调用进程的真实用户 ID 可以创建的伪终端的最大数量。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_RSS

指定进程驻留集的限制（以页为单位）。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_RTPRIO

指定可以为此进程设置的实时优先级的上限。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_RTTIME

指定此进程在实时调度策略下可以消耗的 CPU 时间限制。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_SBSIZE

套接字缓冲区最大大小。

RLIMIT_SIGPENDING

指定可以为调用进程的真实用户 ID 排队的信号数量限制。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIMIT_STACK

堆栈最大大小（以字节为单位）。

有关详细信息，请参阅系统 getrlimit(2) 手册。

RLIM_INFINITY

参见 Process.setrlimit

RLIM_SAVED_CUR

参见 Process.setrlimit

RLIM_SAVED_MAX

参见 Process.setrlimit

WNOHANG

参见 Process.wait

WUNTRACED

参见 Process.wait

公共类方法

_fork → integer 点击切换源代码

fork 的内部 API。不要直接调用此方法。目前，它通过 Kernel#fork、Process.fork 和 IO.popen（使用 "-"）调用。

此方法不适用于普通代码，而是用于应用程序监控库。您可以通过覆盖此方法在 fork 事件之前和之后添加自定义代码。

注意：Process.daemon 可能会使用 fork(2) 实现，但不会经过此方法。因此，根据您挂钩此方法的原因，您可能还需要挂钩那个方法。有关更详细的讨论，请参见此问题。

VALUE
rb_proc__fork(VALUE _obj)
{
    rb_pid_t pid = proc_fork_pid();
    return PIDT2NUM(pid);
}

abort 点击切换源代码

abort(msg = nil)

立即终止执行，实际上是通过调用 Kernel.exit(false) 来实现。

如果给出了字符串参数 msg，则在终止之前将其写入 STDERR；否则，如果引发了异常，则打印其消息和回溯。

static VALUE
f_abort(int c, const VALUE *a, VALUE _)
{
    rb_f_abort(c, a);
    UNREACHABLE_RETURN(Qnil);
}

argv0 → frozen_string 点击切换源代码

返回正在执行的脚本的名称。该值不受将新值分配给 $0 的影响。

此方法首次出现在 Ruby 2.1 中，用作获取脚本名称的无全局变量方法。

static VALUE
proc_argv0(VALUE process)
{
    return rb_orig_progname;
}

clock_getres(clock_id, unit = :float_second) → number 点击切换源代码

返回由 POSIX 函数 clock_getres() 确定的时钟分辨率。

Process.clock_getres(:CLOCK_REALTIME) # => 1.0e-09

有关 clock_id 和 unit 的值，请参见 Process.clock_gettime。

示例

Process.clock_getres(:CLOCK_PROCESS_CPUTIME_ID, :float_microsecond) # => 0.001
Process.clock_getres(:CLOCK_PROCESS_CPUTIME_ID, :float_millisecond) # => 1.0e-06
Process.clock_getres(:CLOCK_PROCESS_CPUTIME_ID, :float_second)      # => 1.0e-09
Process.clock_getres(:CLOCK_PROCESS_CPUTIME_ID, :microsecond)       # => 0
Process.clock_getres(:CLOCK_PROCESS_CPUTIME_ID, :millisecond)       # => 0
Process.clock_getres(:CLOCK_PROCESS_CPUTIME_ID, :nanosecond)        # => 1
Process.clock_getres(:CLOCK_PROCESS_CPUTIME_ID, :second)            # => 0

除了 Process.clock_gettime 中支持的 unit 值之外，此方法还支持 :hertz，即每秒的时钟滴答次数（它是 :float_second 的倒数）。

Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)        # => 100.0
Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :float_second) # => 0.01

准确性: 请注意，由于底层错误，某些平台上返回的分辨率可能不准确。在使用 ARM 处理器或使用虚拟化时，在 Linux、macOS、BSD 或 AIX 平台上，针对包括 :CLOCK_MONOTONIC 和 :CLOCK_MONOTONIC_RAW 在内的各种时钟报告了不准确的分辨率。

static VALUE
rb_clock_getres(int argc, VALUE *argv, VALUE _)
{
    int ret;

    struct timetick tt;
    timetick_int_t numerators[2];
    timetick_int_t denominators[2];
    int num_numerators = 0;
    int num_denominators = 0;
#ifdef HAVE_CLOCK_GETRES
    clockid_t c;
#endif

    VALUE unit = (rb_check_arity(argc, 1, 2) == 2) ? argv[1] : Qnil;
    VALUE clk_id = argv[0];

    if (SYMBOL_P(clk_id)) {
#ifdef CLOCK_REALTIME
        if (clk_id == RUBY_CLOCK_REALTIME) {
            c = CLOCK_REALTIME;
            goto getres;
        }
#endif

#ifdef CLOCK_MONOTONIC
        if (clk_id == RUBY_CLOCK_MONOTONIC) {
            c = CLOCK_MONOTONIC;
            goto getres;
        }
#endif

#ifdef CLOCK_PROCESS_CPUTIME_ID
        if (clk_id == RUBY_CLOCK_PROCESS_CPUTIME_ID) {
            c = CLOCK_PROCESS_CPUTIME_ID;
            goto getres;
        }
#endif

#ifdef CLOCK_THREAD_CPUTIME_ID
        if (clk_id == RUBY_CLOCK_THREAD_CPUTIME_ID) {
            c = CLOCK_THREAD_CPUTIME_ID;
            goto getres;
        }
#endif

#ifdef RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME
        if (clk_id == RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) {
            tt.giga_count = 0;
            tt.count = 1000;
            denominators[num_denominators++] = 1000000000;
            goto success;
        }
#endif

#ifdef RUBY_TIME_BASED_CLOCK_REALTIME
        if (clk_id == RUBY_TIME_BASED_CLOCK_REALTIME) {
            tt.giga_count = 1;
            tt.count = 0;
            denominators[num_denominators++] = 1000000000;
            goto success;
        }
#endif

#ifdef RUBY_TIMES_BASED_CLOCK_MONOTONIC
        if (clk_id == RUBY_TIMES_BASED_CLOCK_MONOTONIC) {
            tt.count = 1;
            tt.giga_count = 0;
            denominators[num_denominators++] = get_clk_tck();
            goto success;
        }
#endif

#ifdef RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID
        if (clk_id == RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) {
            tt.giga_count = 0;
            tt.count = 1000;
            denominators[num_denominators++] = 1000000000;
            goto success;
        }
#endif

#ifdef RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID
        if (clk_id == RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) {
            tt.count = 1;
            tt.giga_count = 0;
            denominators[num_denominators++] = get_clk_tck();
            goto success;
        }
#endif

#ifdef RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID
        if (clk_id == RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) {
            tt.count = 1;
            tt.giga_count = 0;
            denominators[num_denominators++] = CLOCKS_PER_SEC;
            goto success;
        }
#endif

#ifdef RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC
        if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) {
            const mach_timebase_info_data_t *info = get_mach_timebase_info();
            tt.count = 1;
            tt.giga_count = 0;
            numerators[num_numerators++] = info->numer;
            denominators[num_denominators++] = info->denom;
            denominators[num_denominators++] = 1000000000;
            goto success;
        }
#endif
    }
    else if (NUMERIC_CLOCKID) {
#if defined(HAVE_CLOCK_GETRES)
        struct timespec ts;
        c = NUM2CLOCKID(clk_id);
      getres:
        ret = clock_getres(c, &ts);
        if (ret == -1)
            clock_failed("getres", errno, clk_id);
        tt.count = (int32_t)ts.tv_nsec;
        tt.giga_count = ts.tv_sec;
        denominators[num_denominators++] = 1000000000;
        goto success;
#endif
    }
    else {
        rb_unexpected_type(clk_id, T_SYMBOL);
    }
    clock_failed("getres", EINVAL, clk_id);

  success:
    if (unit == ID2SYM(id_hertz)) {
        return timetick2dblnum_reciprocal(&tt, numerators, num_numerators, denominators, num_denominators);
    }
    else {
        return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit);
    }
}

clock_gettime(clock_id, unit = :float_second) → number 点击切换源代码

返回由 POSIX 函数 clock_gettime() 确定的时钟时间。

Process.clock_gettime(:CLOCK_PROCESS_CPUTIME_ID) # => 198.650379677

参数 clock_id 应为一个符号或常量，用于指定要返回其时间的时钟；请参见下文。

可选参数 unit 应为一个符号，用于指定在返回的时钟时间中使用的单位；请参见下文。

参数 clock_id

参数 clock_id 指定要返回其时间的时钟；它可以是常量，例如 Process::CLOCK_REALTIME，或符号缩写，例如 :CLOCK_REALTIME。

支持的时钟取决于底层操作系统；此方法在指定的平台上支持以下时钟（如果使用不支持的时钟调用，则会引发 Errno::EINVAL）

:CLOCK_BOOTTIME: Linux 2.6.39。
:CLOCK_BOOTTIME_ALARM: Linux 3.0。
:CLOCK_MONOTONIC: SUSv3 到 4，Linux 2.5.63，FreeBSD 3.0，NetBSD 2.0，OpenBSD 3.4，macOS 10.12，Windows-2000。
:CLOCK_MONOTONIC_COARSE: Linux 2.6.32。
:CLOCK_MONOTONIC_FAST: FreeBSD 8.1。
:CLOCK_MONOTONIC_PRECISE: FreeBSD 8.1。
:CLOCK_MONOTONIC_RAW: Linux 2.6.28，macOS 10.12。
:CLOCK_MONOTONIC_RAW_APPROX: macOS 10.12。
:CLOCK_PROCESS_CPUTIME_ID: SUSv3 到 4，Linux 2.5.63，FreeBSD 9.3，OpenBSD 5.4，macOS 10.12。
:CLOCK_PROF: FreeBSD 3.0，OpenBSD 2.1。
:CLOCK_REALTIME: SUSv2 到 4，Linux 2.5.63，FreeBSD 3.0，NetBSD 2.0，OpenBSD 2.1，macOS 10.12，Windows-8/Server-2012。 Time.now 建议使用 +:CLOCK_REALTIME:。
:CLOCK_REALTIME_ALARM: Linux 3.0。
:CLOCK_REALTIME_COARSE: Linux 2.6.32。
:CLOCK_REALTIME_FAST: FreeBSD 8.1。
:CLOCK_REALTIME_PRECISE: FreeBSD 8.1。
:CLOCK_SECOND: FreeBSD 8.1。
:CLOCK_TAI: Linux 3.10。
:CLOCK_THREAD_CPUTIME_ID: SUSv3 到 4，Linux 2.5.63，FreeBSD 7.1，OpenBSD 5.4，macOS 10.12。
:CLOCK_UPTIME: FreeBSD 7.0，OpenBSD 5.5。
:CLOCK_UPTIME_FAST: FreeBSD 8.1。
:CLOCK_UPTIME_PRECISE: FreeBSD 8.1。
:CLOCK_UPTIME_RAW: macOS 10.12。
:CLOCK_UPTIME_RAW_APPROX: macOS 10.12。
:CLOCK_VIRTUAL: FreeBSD 3.0, OpenBSD 2.1。

请注意，SUS 代表单一 Unix 规范。SUS 包含 POSIX，而 clock_gettime 在 POSIX 部分中定义。SUS 将 :CLOCK_REALTIME 定义为强制性，但 :CLOCK_MONOTONIC、:CLOCK_PROCESS_CPUTIME_ID 和 :CLOCK_THREAD_CPUTIME_ID 是可选的。

当给定的 clock_id 不被直接支持时，会使用某些模拟。

:CLOCK_REALTIME 的模拟
- :GETTIMEOFDAY_BASED_CLOCK_REALTIME: 使用 SUS 定义的 gettimeofday()（在 SUSv4 中已弃用）。分辨率为 1 微秒。
- :TIME_BASED_CLOCK_REALTIME: 使用 ISO C 定义的 time()。分辨率为 1 秒。
:CLOCK_MONOTONIC 的模拟
- :MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC: 使用 Darwin 上可用的 mach_absolute_time()。分辨率取决于 CPU。
- :TIMES_BASED_CLOCK_MONOTONIC: 使用 POSIX 定义的 times() 的结果值，因此
  
  成功完成时，times() 将返回自过去某个任意点（例如，系统启动时间）以来的经过的实际时间（以时钟滴答数表示）。
  
  例如，GNU/Linux 返回基于 jiffies 的值，它是单调的。但是，4.4BSD 使用 gettimeofday()，它不是单调的。（尽管 FreeBSD 使用 :CLOCK_MONOTONIC。）
  
  分辨率为时钟滴答数。“getconf CLK_TCK” 命令显示每秒的时钟滴答数。（每秒的时钟滴答数在旧系统中由 HZ 宏定义。）如果它是 100 且 clock_t 是 32 位整数类型，则分辨率为 10 毫秒，并且不能表示超过 497 天。
:CLOCK_PROCESS_CPUTIME_ID 的模拟
- :GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID: 使用 SUS 定义的 getrusage()。getrusage() 与 RUSAGE_SELF 一起使用，仅获取调用进程的时间（不包括子进程的时间）。结果是用户时间 (ru_utime) 和系统时间 (ru_stime) 的总和。分辨率为 1 微秒。
- :TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID: 使用 POSIX 定义的 times()。结果是用户时间 (tms_utime) 和系统时间 (tms_stime) 的总和。tms_cutime 和 tms_cstime 被忽略以排除子进程的时间。分辨率为时钟滴答数。“getconf CLK_TCK” 命令显示每秒的时钟滴答数。（每秒的时钟滴答数在旧系统中由 HZ 宏定义。）如果它是 100，则分辨率为 10 毫秒。
- :CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID: 使用 ISO C 定义的 clock() 函数。分辨率为 1/CLOCKS_PER_SEC。CLOCKS_PER_SEC 是由 time.h 定义的 C 级别宏。SUS 将 CLOCKS_PER_SEC 定义为 1000000；其他系统可能定义不同。如果 CLOCKS_PER_SEC 为 1000000（如 SUS），则分辨率为 1 微秒。如果 CLOCKS_PER_SEC 为 1000000 且 clock_t 为 32 位整数类型，则它不能表示超过 72 分钟的时间。

参数 unit

可选参数 unit（默认值为 :float_second）指定返回值的单位。

:float_microsecond: 以浮点数表示的微秒数。
:float_millisecond: 以浮点数表示的毫秒数。
:float_second: 以浮点数表示的秒数。
:microsecond: 以整数表示的微秒数。
:millisecond: 以整数表示的毫秒数。
:nanosecond: 以整数表示的纳秒数。
::second: 以整数表示的秒数。

示例

Process.clock_gettime(:CLOCK_PROCESS_CPUTIME_ID, :float_microsecond)
# => 203605054.825
Process.clock_gettime(:CLOCK_PROCESS_CPUTIME_ID, :float_millisecond)
# => 203643.696848
Process.clock_gettime(:CLOCK_PROCESS_CPUTIME_ID, :float_second)
# => 203.762181929
Process.clock_gettime(:CLOCK_PROCESS_CPUTIME_ID, :microsecond)
# => 204123212
Process.clock_gettime(:CLOCK_PROCESS_CPUTIME_ID, :millisecond)
# => 204298
Process.clock_gettime(:CLOCK_PROCESS_CPUTIME_ID, :nanosecond)
# => 204602286036
Process.clock_gettime(:CLOCK_PROCESS_CPUTIME_ID, :second)
# => 204

底层函数 clock_gettime() 返回纳秒数。对于 :CLOCK_REALTIME，Float 对象（IEEE 754 双精度浮点数）不足以表示返回值。如果需要精确的纳秒值，请使用 :nanosecond 作为 unit。

返回值的起点（时间零）取决于系统，例如，可能是系统启动时间、进程启动时间、纪元等。

:CLOCK_REALTIME 中的起点定义为纪元：1970-01-01 00:00:00 UTC；一些系统计算闰秒，而另一些系统则不计算，因此结果可能因系统而异。

static VALUE
rb_clock_gettime(int argc, VALUE *argv, VALUE _)
{
    int ret;

    struct timetick tt;
    timetick_int_t numerators[2];
    timetick_int_t denominators[2];
    int num_numerators = 0;
    int num_denominators = 0;

    VALUE unit = (rb_check_arity(argc, 1, 2) == 2) ? argv[1] : Qnil;
    VALUE clk_id = argv[0];
#ifdef HAVE_CLOCK_GETTIME
    clockid_t c;
#endif

    if (SYMBOL_P(clk_id)) {
#ifdef CLOCK_REALTIME
        if (clk_id == RUBY_CLOCK_REALTIME) {
            c = CLOCK_REALTIME;
            goto gettime;
        }
#endif

#ifdef CLOCK_MONOTONIC
        if (clk_id == RUBY_CLOCK_MONOTONIC) {
            c = CLOCK_MONOTONIC;
            goto gettime;
        }
#endif

#ifdef CLOCK_PROCESS_CPUTIME_ID
        if (clk_id == RUBY_CLOCK_PROCESS_CPUTIME_ID) {
            c = CLOCK_PROCESS_CPUTIME_ID;
            goto gettime;
        }
#endif

#ifdef CLOCK_THREAD_CPUTIME_ID
        if (clk_id == RUBY_CLOCK_THREAD_CPUTIME_ID) {
            c = CLOCK_THREAD_CPUTIME_ID;
            goto gettime;
        }
#endif

        /*
         * Non-clock_gettime clocks are provided by symbol clk_id.
         */
#ifdef HAVE_GETTIMEOFDAY
        /*
         * GETTIMEOFDAY_BASED_CLOCK_REALTIME is used for
         * CLOCK_REALTIME if clock_gettime is not available.
         */
#define RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME ID2SYM(id_GETTIMEOFDAY_BASED_CLOCK_REALTIME)
        if (clk_id == RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) {
            struct timeval tv;
            ret = gettimeofday(&tv, 0);
            if (ret != 0)
                rb_sys_fail("gettimeofday");
            tt.giga_count = tv.tv_sec;
            tt.count = (int32_t)tv.tv_usec * 1000;
            denominators[num_denominators++] = 1000000000;
            goto success;
        }
#endif

#define RUBY_TIME_BASED_CLOCK_REALTIME ID2SYM(id_TIME_BASED_CLOCK_REALTIME)
        if (clk_id == RUBY_TIME_BASED_CLOCK_REALTIME) {
            time_t t;
            t = time(NULL);
            if (t == (time_t)-1)
                rb_sys_fail("time");
            tt.giga_count = t;
            tt.count = 0;
            denominators[num_denominators++] = 1000000000;
            goto success;
        }

#ifdef HAVE_TIMES
#define RUBY_TIMES_BASED_CLOCK_MONOTONIC \
        ID2SYM(id_TIMES_BASED_CLOCK_MONOTONIC)
        if (clk_id == RUBY_TIMES_BASED_CLOCK_MONOTONIC) {
            struct tms buf;
            clock_t c;
            unsigned_clock_t uc;
            c = times(&buf);
            if (c ==  (clock_t)-1)
                rb_sys_fail("times");
            uc = (unsigned_clock_t)c;
            tt.count = (int32_t)(uc % 1000000000);
            tt.giga_count = (uc / 1000000000);
            denominators[num_denominators++] = get_clk_tck();
            goto success;
        }
#endif

#ifdef RUSAGE_SELF
#define RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID \
        ID2SYM(id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID)
        if (clk_id == RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) {
            struct rusage usage;
            int32_t usec;
            ret = getrusage(RUSAGE_SELF, &usage);
            if (ret != 0)
                rb_sys_fail("getrusage");
            tt.giga_count = usage.ru_utime.tv_sec + usage.ru_stime.tv_sec;
            usec = (int32_t)(usage.ru_utime.tv_usec + usage.ru_stime.tv_usec);
            if (1000000 <= usec) {
                tt.giga_count++;
                usec -= 1000000;
            }
            tt.count = usec * 1000;
            denominators[num_denominators++] = 1000000000;
            goto success;
        }
#endif

#ifdef HAVE_TIMES
#define RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID \
        ID2SYM(id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID)
        if (clk_id == RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) {
            struct tms buf;
            unsigned_clock_t utime, stime;
            if (times(&buf) ==  (clock_t)-1)
                rb_sys_fail("times");
            utime = (unsigned_clock_t)buf.tms_utime;
            stime = (unsigned_clock_t)buf.tms_stime;
            tt.count = (int32_t)((utime % 1000000000) + (stime % 1000000000));
            tt.giga_count = (utime / 1000000000) + (stime / 1000000000);
            if (1000000000 <= tt.count) {
                tt.count -= 1000000000;
                tt.giga_count++;
            }
            denominators[num_denominators++] = get_clk_tck();
            goto success;
        }
#endif

#define RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID \
        ID2SYM(id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID)
        if (clk_id == RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) {
            clock_t c;
            unsigned_clock_t uc;
            errno = 0;
            c = clock();
            if (c == (clock_t)-1)
                rb_sys_fail("clock");
            uc = (unsigned_clock_t)c;
            tt.count = (int32_t)(uc % 1000000000);
            tt.giga_count = uc / 1000000000;
            denominators[num_denominators++] = CLOCKS_PER_SEC;
            goto success;
        }

#ifdef __APPLE__
        if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) {
            const mach_timebase_info_data_t *info = get_mach_timebase_info();
            uint64_t t = mach_absolute_time();
            tt.count = (int32_t)(t % 1000000000);
            tt.giga_count = t / 1000000000;
            numerators[num_numerators++] = info->numer;
            denominators[num_denominators++] = info->denom;
            denominators[num_denominators++] = 1000000000;
            goto success;
        }
#endif
    }
    else if (NUMERIC_CLOCKID) {
#if defined(HAVE_CLOCK_GETTIME)
        struct timespec ts;
        c = NUM2CLOCKID(clk_id);
      gettime:
        ret = clock_gettime(c, &ts);
        if (ret == -1)
            clock_failed("gettime", errno, clk_id);
        tt.count = (int32_t)ts.tv_nsec;
        tt.giga_count = ts.tv_sec;
        denominators[num_denominators++] = 1000000000;
        goto success;
#endif
    }
    else {
        rb_unexpected_type(clk_id, T_SYMBOL);
    }
    clock_failed("gettime", EINVAL, clk_id);

  success:
    return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit);
}

daemon(nochdir = nil, noclose = nil) → 0 点击以切换源代码

将当前进程与其控制终端分离，并在后台作为系统守护进程运行；返回零。

默认情况下

将当前工作目录更改为根目录。
将 $stdin、$stdout 和 $stderr 重定向到空设备。

如果可选参数 nochdir 为 true，则不更改当前工作目录。

如果可选参数 noclose 为 true，则不重定向 $stdin、$stdout 或 $stderr。

static VALUE
proc_daemon(int argc, VALUE *argv, VALUE _)
{
    int n, nochdir = FALSE, noclose = FALSE;

    switch (rb_check_arity(argc, 0, 2)) {
      case 2: noclose = TO_BOOL(argv[1], "noclose");
      case 1: nochdir = TO_BOOL(argv[0], "nochdir");
    }

    prefork();
    n = rb_daemon(nochdir, noclose);
    if (n < 0) rb_sys_fail("daemon");
    return INT2FIX(n);
}

detach(pid) → thread 点击以切换源代码

避免子进程可能成为僵尸进程。 Process.detach 通过设置一个单独的 Ruby 线程来防止这种情况，该线程的唯一工作是在进程 pid 终止时收集其状态。

仅当父进程永远不会等待子进程时才需要此方法。

此示例不会收集第二个子进程；该进程在进程状态 (ps) 输出中显示为僵尸进程

pid = Process.spawn('ruby', '-e', 'exit 13') # => 312691
sleep(1)
# Find zombies.
system("ps -ho pid,state -p #{pid}")

输出

312716 Z

此示例也不会收集第二个子进程，但它确实分离了进程，因此它不会成为僵尸进程

pid = Process.spawn('ruby', '-e', 'exit 13') # => 313213
thread = Process.detach(pid)
sleep(1)
# => #<Process::Waiter:0x00007f038f48b838 run>
system("ps -ho pid,state -p #{pid}")        # Finds no zombies.

等待线程可以返回分离的子进程的 pid

thread.join.pid                       # => 313262

static VALUE
proc_detach(VALUE obj, VALUE pid)
{
    return rb_detach_process(NUM2PIDT(pid));
}

egid → integer 点击切换源代码

Process::GID.eid → integer

Process::Sys.geteid → integer

返回当前进程的有效组 ID。

Process.egid # => 500

并非所有平台都可用。

static VALUE
proc_getegid(VALUE obj)
{
    rb_gid_t egid = getegid();

    return GIDT2NUM(egid);
}

egid = new_egid → new_egid 点击切换源代码

设置当前进程的有效组 ID。

并非所有平台都可用。

static VALUE
proc_setegid(VALUE obj, VALUE egid)
{
#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID)
    rb_gid_t gid;
#endif

    check_gid_switch();

#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID)
    gid = OBJ2GID(egid);
#endif

#if defined(HAVE_SETRESGID)
    if (setresgid(-1, gid, -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETREGID
    if (setregid(-1, gid) < 0) rb_sys_fail(0);
#elif defined HAVE_SETEGID
    if (setegid(gid) < 0) rb_sys_fail(0);
#elif defined HAVE_SETGID
    if (gid == getgid()) {
        if (setgid(gid) < 0) rb_sys_fail(0);
    }
    else {
        rb_notimplement();
    }
#else
    rb_notimplement();
#endif
    return egid;
}

euid → integer 点击切换源代码

Process::UID.eid → integer

Process::Sys.geteuid → integer

返回当前进程的有效用户 ID。

Process.euid # => 501

static VALUE
proc_geteuid(VALUE obj)
{
    rb_uid_t euid = geteuid();
    return UIDT2NUM(euid);
}

euid = new_euid → new_euid 点击切换源代码

设置当前进程的有效用户 ID。

并非所有平台都可用。

static VALUE
proc_seteuid_m(VALUE mod, VALUE euid)
{
    check_uid_switch();
    proc_seteuid(OBJ2UID(euid));
    return euid;
}

exec([env, ] command_line, options = {}) 点击切换源代码

exec([env, ] exe_path, *args, options = {})

通过以下方式之一替换当前进程：

将字符串 command_line 传递给 shell。
调用 exe_path 中的可执行文件。

如果使用不可信输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

新进程使用 exec 系统调用创建；它可能会从调用程序继承其部分环境（可能包括打开的文件描述符）。

如果给出参数 env，则它是一个哈希，会影响新进程的 ENV；请参阅执行环境。

参数 options 是新进程的选项哈希；请参阅执行选项。

第一个必需参数是以下之一：

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置命令开头，或者如果它包含一个或多个元字符。
exe_path 否则。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头，以特殊内置函数开头，或包含元字符

exec('if true; then echo "Foo"; fi') # Shell reserved word.
exec('echo')                         # Built-in.
exec('date > date.tmp')              # Contains meta character.

命令行还可以包含命令的参数和选项

exec('echo "Foo"')

输出

Foo

有关 shell 的详细信息，请参阅执行 shell。

如果新进程无法执行，则引发异常。

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
包含可执行文件路径和用作执行进程名称的字符串的二维数组。

示例

exec('/usr/bin/date')

输出

Sat Aug 26 09:38:00 AM CDT 2023

Ruby 直接调用可执行文件，不使用 shell 也不进行 shell 展开。

exec('doesnt_exist') # Raises Errno::ENOENT

如果给出了一个或多个 args，则每个都是要传递给可执行文件的参数或选项。

exec('echo', 'C*')
exec('echo', 'hello', 'world')

输出

C*
hello world

如果新进程无法执行，则引发异常。

static VALUE
f_exec(int c, const VALUE *a, VALUE _)
{
    rb_f_exec(c, a);
    UNREACHABLE_RETURN(Qnil);
}

exit(status = true) 点击切换源代码

exit(status = true)

通过引发 SystemExit 来启动 Ruby 脚本的终止；可以捕获该异常。将退出状态 status 返回给底层操作系统。

参数 status 的值 true 和 false 分别表示成功和失败；整数值的含义取决于系统。

示例

begin
  exit
  puts 'Never get here.'
rescue SystemExit
  puts 'Rescued a SystemExit exception.'
end
puts 'After begin block.'

输出

Rescued a SystemExit exception.
After begin block.

在最终终止之前，Ruby 会执行任何退出时过程（请参阅 Kernel::at_exit）和任何对象终结器（请参阅 ObjectSpace::define_finalizer）。

示例

at_exit { puts 'In at_exit function.' }
ObjectSpace.define_finalizer('string', proc { puts 'In finalizer.' })
exit

输出

In at_exit function.
In finalizer.

static VALUE
f_exit(int c, const VALUE *a, VALUE _)
{
    rb_f_exit(c, a);
    UNREACHABLE_RETURN(Qnil);
}

exit!(status = false) 点击切换源代码

exit!(status = false)

立即退出进程；不会调用任何退出处理程序。将退出状态 status 返回给底层操作系统。

Process.exit!(true)

参数 status 的值 true 和 false 分别表示成功和失败；整数值的含义取决于系统。

static VALUE
rb_f_exit_bang(int argc, VALUE *argv, VALUE obj)
{
    int istatus;

    if (rb_check_arity(argc, 0, 1) == 1) {
        istatus = exit_status_code(argv[0]);
    }
    else {
        istatus = EXIT_FAILURE;
    }
    _exit(istatus);

    UNREACHABLE_RETURN(Qnil);
}

fork { ... } → 整数或 nil 点击切换源代码

fork → 整数或 nil

创建子进程。

如果给定代码块，则在子进程中运行代码块；代码块退出时，子进程以状态码 0 终止。

puts "Before the fork: #{Process.pid}"
fork do
  puts "In the child process: #{Process.pid}"
end                   # => 382141
puts "After the fork: #{Process.pid}"

输出

Before the fork: 420496
After the fork: 420496
In the child process: 420520

如果没有给定代码块，fork 调用将返回两次。

一次在父进程中返回，返回子进程的 pid。
一次在子进程中返回，返回 nil。

示例

puts "This is the first line before the fork (pid #{Process.pid})"
puts fork
puts "This is the second line after the fork (pid #{Process.pid})"

输出

This is the first line before the fork (pid 420199)
420223
This is the second line after the fork (pid 420199)

This is the second line after the fork (pid 420223)

在这两种情况下，子进程都可以使用 Kernel.exit! 退出，以避免调用 Kernel#at_exit。

为了避免僵尸进程，父进程应该调用以下方法之一：

Process.wait，收集其子进程的终止状态。
Process.detach，注册对子进程状态的不感兴趣。

调用 fork 的线程是创建的子进程中的唯一线程；fork 不会复制其他线程。

请注意，fork 方法在某些平台上可用，但在其他平台上不可用。

Process.respond_to?(:fork) # => true # Would be false on some.

如果不是，可以使用 ::spawn 代替 fork。

static VALUE
rb_f_fork(VALUE obj)
{
    rb_pid_t pid;

    pid = rb_call_proc__fork();

    if (pid == 0) {
        if (rb_block_given_p()) {
            int status;
            rb_protect(rb_yield, Qundef, &status);
            ruby_stop(status);
        }
        return Qnil;
    }

    return PIDT2NUM(pid);
}

getpgid(pid) → 整数点击切换源代码

Returns the process group ID for the given process ID +pid+:

  Process.getpgid(Process.ppid) # => 25527

并非所有平台都可用。

static VALUE
proc_getpgid(VALUE obj, VALUE pid)
{
    rb_pid_t i;

    i = getpgid(NUM2PIDT(pid));
    if (i < 0) rb_sys_fail(0);
    return PIDT2NUM(i);
}

getpgrp → 整数点击切换源代码

返回当前进程的进程组 ID。

Process.getpgid(0) # => 25527
Process.getpgrp    # => 25527

static VALUE
proc_getpgrp(VALUE _)
{
    rb_pid_t pgrp;

#if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID)
    pgrp = getpgrp();
    if (pgrp < 0) rb_sys_fail(0);
    return PIDT2NUM(pgrp);
#else /* defined(HAVE_GETPGID) */
    pgrp = getpgid(0);
    if (pgrp < 0) rb_sys_fail(0);
    return PIDT2NUM(pgrp);
#endif
}

getpriority(kind, id) → 整数点击切换源代码

返回指定进程、进程组或用户的调度优先级。

参数 kind 是以下之一：

Process::PRIO_PROCESS：返回进程的优先级。
Process::PRIO_PGRP：返回进程组的优先级。
Process::PRIO_USER：返回用户的优先级。

参数 id 是进程、进程组或用户的 ID；对于 kind，0 表示当前 ID。

示例

Process.getpriority(Process::PRIO_USER, 0)    # => 19
Process.getpriority(Process::PRIO_PROCESS, 0) # => 19

并非所有平台都可用。

static VALUE
proc_getpriority(VALUE obj, VALUE which, VALUE who)
{
    int prio, iwhich, iwho;

    iwhich = NUM2INT(which);
    iwho   = NUM2INT(who);

    errno = 0;
    prio = getpriority(iwhich, iwho);
    if (errno) rb_sys_fail(0);
    return INT2FIX(prio);
}

getrlimit(resource) → [cur_limit, max_limit] 点击切换源代码

返回给定 resource 的当前（软）限制和最大（硬）限制的 2 元素数组。

参数 resource 指定要返回其限制的资源；请参阅 Process.setrlimit。

返回的每个值 cur_limit 和 max_limit 都是一个整数；请参阅 Process.setrlimit。

示例

Process.getrlimit(:CORE) # => [0, 18446744073709551615]

请参阅 Process.setrlimit。

并非所有平台都可用。

static VALUE
proc_getrlimit(VALUE obj, VALUE resource)
{
    struct rlimit rlim;

    if (getrlimit(rlimit_resource_type(resource), &rlim) < 0) {
        rb_sys_fail("getrlimit");
    }
    return rb_assoc_new(RLIM2NUM(rlim.rlim_cur), RLIM2NUM(rlim.rlim_max));
}

getsid(pid = nil) → 整数点击切换源代码

返回给定进程 ID pid 的会话 ID，如果没有给出，则返回当前进程的会话 ID。

Process.getsid                # => 27422
Process.getsid(0)             # => 27422
Process.getsid(Process.pid()) # => 27422

并非所有平台都可用。

static VALUE
proc_getsid(int argc, VALUE *argv, VALUE _)
{
    rb_pid_t sid;
    rb_pid_t pid = 0;

    if (rb_check_arity(argc, 0, 1) == 1 && !NIL_P(argv[0]))
        pid = NUM2PIDT(argv[0]);

    sid = getsid(pid);
    if (sid < 0) rb_sys_fail(0);
    return PIDT2NUM(sid);
}

gid → 整数点击切换源代码

Process::GID.rid → 整数

Process::Sys.getgid → 整数

返回当前进程的（真实）组 ID

Process.gid # => 1000

static VALUE
proc_getgid(VALUE obj)
{
    rb_gid_t gid = getgid();
    return GIDT2NUM(gid);
}

gid = new_gid → new_gid 点击切换源代码

将当前进程的组 ID 设置为 new_gid

Process.gid = 1000 # => 1000

static VALUE
proc_setgid(VALUE obj, VALUE id)
{
    rb_gid_t gid;

    check_gid_switch();

    gid = OBJ2GID(id);
#if defined(HAVE_SETRESGID)
    if (setresgid(gid, -1, -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETREGID
    if (setregid(gid, -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETRGID
    if (setrgid(gid) < 0) rb_sys_fail(0);
#elif defined HAVE_SETGID
    {
        if (getegid() == gid) {
            if (setgid(gid) < 0) rb_sys_fail(0);
        }
        else {
            rb_notimplement();
        }
    }
#endif
    return GIDT2NUM(gid);
}

groups → 数组点击切换源代码

返回当前进程的补充组访问列表中的组 ID 数组

Process.groups # => [4, 24, 27, 30, 46, 122, 135, 136, 1000]

返回数组的这些属性取决于系统

数组是否（以及如何）排序。
数组是否包含有效组 ID。
数组是否包含重复的组 ID。
数组大小是否超过 Process.maxgroups 的值。

使用此调用获取排序且唯一的数组

Process.groups.uniq.sort

static VALUE
proc_getgroups(VALUE obj)
{
    VALUE ary, tmp;
    int i, ngroups;
    rb_gid_t *groups;

    ngroups = getgroups(0, NULL);
    if (ngroups == -1)
        rb_sys_fail(0);

    groups = ALLOCV_N(rb_gid_t, tmp, ngroups);

    ngroups = getgroups(ngroups, groups);
    if (ngroups == -1)
        rb_sys_fail(0);

    ary = rb_ary_new();
    for (i = 0; i < ngroups; i++)
        rb_ary_push(ary, GIDT2NUM(groups[i]));

    ALLOCV_END(tmp);

    return ary;
}

groups = new_groups → new_groups 点击切换源代码

将补充组访问列表设置为给定的组 ID 数组。

Process.groups                     # => [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.groups = [27, 6, 10, 11]   # => [27, 6, 10, 11]
Process.groups                     # => [27, 6, 10, 11]

static VALUE
proc_setgroups(VALUE obj, VALUE ary)
{
    int ngroups, i;
    rb_gid_t *groups;
    VALUE tmp;
    PREPARE_GETGRNAM;

    Check_Type(ary, T_ARRAY);

    ngroups = RARRAY_LENINT(ary);
    if (ngroups > maxgroups())
        rb_raise(rb_eArgError, "too many groups, %d max", maxgroups());

    groups = ALLOCV_N(rb_gid_t, tmp, ngroups);

    for (i = 0; i < ngroups; i++) {
        VALUE g = RARRAY_AREF(ary, i);

        groups[i] = OBJ2GID1(g);
    }
    FINISH_GETGRNAM;

    if (setgroups(ngroups, groups) == -1) /* ngroups <= maxgroups */
        rb_sys_fail(0);

    ALLOCV_END(tmp);

    return proc_getgroups(obj);
}

initgroups(username, gid) → 数组点击切换源代码

设置补充组访问列表；新列表包括

username 指定的用户所属的组的组 ID。
组 ID gid。

示例

Process.groups                # => [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
Process.initgroups('me', 30)  # => [30, 6, 10, 11]
Process.groups                # => [30, 6, 10, 11]

并非所有平台都可用。

static VALUE
proc_initgroups(VALUE obj, VALUE uname, VALUE base_grp)
{
    if (initgroups(StringValueCStr(uname), OBJ2GID(base_grp)) != 0) {
        rb_sys_fail(0);
    }
    return proc_getgroups(obj);
}

kill(signal, *ids) → 计数点击切换源代码

向 ids 指定的每个进程发送信号（必须指定至少一个 ID）；返回发送的信号计数。

对于每个给定的 id，如果 id 是

正数，则向进程 ID 为 id 的进程发送信号。
零，则向当前进程组中的所有进程发送信号。
负数，则向系统相关的进程集合发送信号。

参数 signal 指定要发送的信号；参数可以是

整数信号编号：例如，-29、0、29。
信号名称（字符串），带或不带前导 'SIG'，带或不带前缀减号 ('-')：例如
- 'SIGPOLL'.
- 'POLL',
- '-SIGPOLL'.
- '-POLL'.
信号符号，带或不带前导 'SIG'，带或不带前缀减号 ('-')：例如
- :SIGPOLL.
- :POLL.
- :'-SIGPOLL'.
- :'-POLL'.

如果 signal 是

一个非负整数，或一个没有前缀 '-' 的信号名称或符号，则会向每个进程 ID 为 id 的进程发送信号。
一个负整数，或一个有前缀 '-' 的信号名称或符号，则会向每个组 ID 为 id 的进程组发送信号。

使用方法 Signal.list 查看 Ruby 在底层平台上支持哪些信号；该方法返回一个哈希表，其中包含支持信号的字符串名称和非负整数值。返回的哈希表的大小和内容在不同平台之间差异很大。

此外，信号 0 用于确定进程是否存在。

示例

pid = fork do
  Signal.trap('HUP') { puts 'Ouch!'; exit }
  # ... do some work ...
end
# ...
Process.kill('HUP', pid)
Process.wait

输出

Ouch!

异常

如果 signal 是一个整数但无效，则会引发 Errno::EINVAL 或 RangeError。
如果 signal 是一个字符串或符号但无效，则会引发 ArgumentError。
如果 ids 中的一个无效，则会引发 Errno::ESRCH 或 RangeError。
如果所需的权限未生效，则会引发 Errno::EPERM。

在最后两种情况下，信号可能已发送到某些进程。

static VALUE
proc_rb_f_kill(int c, const VALUE *v, VALUE _)
{
    return rb_f_kill(c, v);
}

last_status → Process::Status 或 nil 点击切换源代码

返回一个 Process::Status 对象，表示当前线程中最近退出的子进程，如果不存在则返回 nil

Process.spawn('ruby', '-e', 'exit 13')
Process.wait
Process.last_status # => #<Process::Status: pid 14396 exit 13>

Process.spawn('ruby', '-e', 'exit 14')
Process.wait
Process.last_status # => #<Process::Status: pid 4692 exit 14>

Process.spawn('ruby', '-e', 'exit 15')
# 'exit 15' has not been reaped by #wait.
Process.last_status # => #<Process::Status: pid 4692 exit 14>
Process.wait
Process.last_status # => #<Process::Status: pid 1380 exit 15>

static VALUE
proc_s_last_status(VALUE mod)
{
    return rb_last_status_get();
}

maxgroups → integer 点击切换源代码

返回补充组访问列表中允许的最大组 ID 数量

Process.maxgroups # => 32

static VALUE
proc_getmaxgroups(VALUE obj)
{
    return INT2FIX(maxgroups());
}

maxgroups = new_max → new_max 点击切换源代码

设置补充组访问列表中允许的最大组 ID 数量。

static VALUE
proc_setmaxgroups(VALUE obj, VALUE val)
{
    int ngroups = FIX2INT(val);
    int ngroups_max = get_sc_ngroups_max();

    if (ngroups <= 0)
        rb_raise(rb_eArgError, "maxgroups %d should be positive", ngroups);

    if (ngroups > RB_MAX_GROUPS)
        ngroups = RB_MAX_GROUPS;

    if (ngroups_max > 0 && ngroups > ngroups_max)
        ngroups = ngroups_max;

    _maxgroups = ngroups;

    return INT2FIX(_maxgroups);
}

pid → integer 点击切换源代码

返回当前进程的进程 ID

Process.pid # => 15668

static VALUE
proc_get_pid(VALUE _)
{
    return get_pid();
}

ppid → integer 点击切换源代码

返回当前进程父进程的进程 ID

puts "Pid is #{Process.pid}."
fork { puts "Parent pid is #{Process.ppid}." }

输出

Pid is 271290.
Parent pid is 271290

在某些平台上可能无法返回可靠的值。

static VALUE
proc_get_ppid(VALUE _)
{
    return get_ppid();
}

setpgid(pid, pgid) → 0 点击切换源代码

将进程 ID 为 pid 的进程的进程组 ID 设置为 pgid。

并非所有平台都可用。

static VALUE
proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp)
{
    rb_pid_t ipid, ipgrp;

    ipid = NUM2PIDT(pid);
    ipgrp = NUM2PIDT(pgrp);

    if (setpgid(ipid, ipgrp) < 0) rb_sys_fail(0);
    return INT2FIX(0);
}

setpgrp → 0 点击切换源代码

等效于 setpgid(0, 0)。

并非所有平台都可用。

static VALUE
proc_setpgrp(VALUE _)
{
  /* check for posix setpgid() first; this matches the posix */
  /* getpgrp() above.  It appears that configure will set SETPGRP_VOID */
  /* even though setpgrp(0,0) would be preferred. The posix call avoids */
  /* this confusion. */
#ifdef HAVE_SETPGID
    if (setpgid(0,0) < 0) rb_sys_fail(0);
#elif defined(HAVE_SETPGRP) && defined(SETPGRP_VOID)
    if (setpgrp() < 0) rb_sys_fail(0);
#endif
    return INT2FIX(0);
}

setpriority(kind, integer, priority) → 0 点击切换源代码

参见 Process.getpriority。

示例

Process.setpriority(Process::PRIO_USER, 0, 19)    # => 0
Process.setpriority(Process::PRIO_PROCESS, 0, 19) # => 0
Process.getpriority(Process::PRIO_USER, 0)        # => 19
Process.getpriority(Process::PRIO_PROCESS, 0)     # => 19

并非所有平台都可用。

static VALUE
proc_setpriority(VALUE obj, VALUE which, VALUE who, VALUE prio)
{
    int iwhich, iwho, iprio;

    iwhich = NUM2INT(which);
    iwho   = NUM2INT(who);
    iprio  = NUM2INT(prio);

    if (setpriority(iwhich, iwho, iprio) < 0)
        rb_sys_fail(0);
    return INT2FIX(0);
}

setproctitle(string) → string 点击切换源代码

设置在 ps(1) 命令中显示的进程标题。并非在所有平台上都有效。无论结果如何，都不会引发异常，即使平台不支持该功能，也不会引发 NotImplementedError。

调用此方法不会影响 $0 的值。

Process.setproctitle('myapp: worker #%d' % worker_id)

此方法首次出现在 Ruby 2.1 中，用作更改进程标题的全局变量免费方法。

static VALUE
proc_setproctitle(VALUE process, VALUE title)
{
    return ruby_setproctitle(title);
}

setrlimit(resource, cur_limit, max_limit = cur_limit) → nil 点击切换源代码

为当前进程设置给定 resource 的限制为 cur_limit（软限制）和 max_limit（硬限制）；返回 nil。

参数 resource 指定要设置限制的资源；参数可以作为符号、字符串或以 Process::RLIMIT_ 开头的常量给出（例如，:CORE、'CORE' 或 Process::RLIMIT_CORE）。

可用的和支持的资源是系统相关的，可能包括（这里用符号表示）

:AS: 可用总内存（字节）（SUSv3、NetBSD、FreeBSD、OpenBSD 除 4.4BSD-Lite 外）。
:CORE: 内核大小（字节）（SUSv3）。
:CPU: CPU 时间（秒）（SUSv3）。
:DATA: Data 段（字节）（SUSv3）。
:FSIZE: File 大小（字节）（SUSv3）。
:MEMLOCK: mlock(2) 的总大小（字节）（4.4BSD、GNU/Linux）。
:MSGQUEUE: POSIX 消息队列的分配（字节）（GNU/Linux）。
:NICE: 进程 nice(2) 值的上限（数字）（GNU/Linux）。
:NOFILE: File 描述符（数字）（SUSv3）。
:NPROC: 用户的进程数（数字）（4.4BSD、GNU/Linux）。
:NPTS: 伪终端的数量（数字）（FreeBSD）。
:RSS: 常驻内存大小（字节）（4.2BSD、GNU/Linux）。
:RTPRIO: 进程实时优先级的上限（数字）（GNU/Linux）。
:RTTIME: 实时进程的 CPU 时间（us）（GNU/Linux）。
:SBSIZE: 所有套接字缓冲区（字节）（NetBSD，FreeBSD）。
:SIGPENDING: 允许的排队信号数量（信号）（GNU/Linux）。
:STACK: 堆栈大小（字节）（SUSv3）。

参数 cur_limit 和 max_limit 可以是

整数（max_limit 不应小于 cur_limit）。
Symbol :SAVED_MAX，字符串 'SAVED_MAX'，或常量 Process::RLIM_SAVED_MAX：保存的最大限制。
Symbol :SAVED_CUR，字符串 'SAVED_CUR'，或常量 Process::RLIM_SAVED_CUR：保存的当前限制。
Symbol :INFINITY，字符串 'INFINITY'，或常量 Process::RLIM_INFINITY：对资源没有限制。

此示例将核心大小的软限制提高到硬限制，以尝试使核心转储成为可能

Process.setrlimit(:CORE, Process.getrlimit(:CORE)[1])

并非所有平台都可用。

static VALUE
proc_setrlimit(int argc, VALUE *argv, VALUE obj)
{
    VALUE resource, rlim_cur, rlim_max;
    struct rlimit rlim;

    rb_check_arity(argc, 2, 3);
    resource = argv[0];
    rlim_cur = argv[1];
    if (argc < 3 || NIL_P(rlim_max = argv[2]))
        rlim_max = rlim_cur;

    rlim.rlim_cur = rlimit_resource_value(rlim_cur);
    rlim.rlim_max = rlimit_resource_value(rlim_max);

    if (setrlimit(rlimit_resource_type(resource), &rlim) < 0) {
        rb_sys_fail("setrlimit");
    }
    return Qnil;
}

setsid → integer 点击切换源代码

将当前进程建立为新的会话和进程组领导者，没有控制终端；返回会话 ID

Process.setsid # => 27422

并非所有平台都可用。

static VALUE
proc_setsid(VALUE _)
{
    rb_pid_t pid;

    pid = setsid();
    if (pid < 0) rb_sys_fail(0);
    return PIDT2NUM(pid);
}

spawn([env, ] command_line, options = {}) → pid 点击切换源代码

spawn([env, ] exe_path, *args, options = {}) → pid

通过在该进程中执行以下操作之一来创建一个新的子进程

将字符串 command_line 传递给 shell。
调用 exe_path 中的可执行文件。

如果使用不可信输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

返回新进程的进程 ID (pid)，而不等待它完成。

为了避免僵尸进程，父进程应该调用以下方法之一：

Process.wait，收集其子进程的终止状态。
Process.detach，注册对子进程状态的不感兴趣。

新进程使用 exec 系统调用创建；它可能会从调用程序继承其部分环境（可能包括打开的文件描述符）。

如果给出参数 env，则它是一个哈希，会影响新进程的 ENV；请参阅执行环境。

参数 options 是新进程的选项哈希；请参阅执行选项。

第一个必需参数是以下之一：

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置命令开头，或者如果它包含一个或多个元字符。
exe_path 否则。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头，以特殊内置函数开头，或包含元字符

spawn('if true; then echo "Foo"; fi') # => 798847 # Shell reserved word.
Process.wait                          # => 798847
spawn('echo')                         # => 798848 # Built-in.
Process.wait                          # => 798848
spawn('date > /tmp/date.tmp')         # => 798879 # Contains meta character.
Process.wait                          # => 798849
spawn('date > /nop/date.tmp')         # => 798882 # Issues error message.
Process.wait                          # => 798882

命令行还可以包含命令的参数和选项

spawn('echo "Foo"') # => 799031
Process.wait        # => 799031

输出

Foo

有关 shell 的详细信息，请参阅执行 shell。

如果新进程无法执行，则引发异常。

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径

spawn('/usr/bin/date') # Path to date on Unix-style system.
Process.wait

输出

Thu Aug 31 10:06:48 AM CDT 2023

包含可执行文件路径和用作正在执行进程的名称的字符串的 2 元素数组

pid = spawn(['sleep', 'Hello!'], '1') # 2-element array.
p `ps -p #{pid} -o command=`

输出

"Hello! 1\n"

Ruby 直接调用可执行文件，没有 shell 也没有 shell 展开。

如果给出了一个或多个 args，则每个都是要传递给可执行文件的参数或选项。

spawn('echo', 'C*')             # => 799392
Process.wait                    # => 799392
spawn('echo', 'hello', 'world') # => 799393
Process.wait                    # => 799393

输出

C*
hello world

如果新进程无法执行，则引发异常。

static VALUE
rb_f_spawn(int argc, VALUE *argv, VALUE _)
{
    rb_pid_t pid;
    char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
    VALUE execarg_obj, fail_str;
    struct rb_execarg *eargp;

    execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE);
    eargp = rb_execarg_get(execarg_obj);
    fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;

    pid = rb_execarg_spawn(execarg_obj, errmsg, sizeof(errmsg));

    if (pid == -1) {
        int err = errno;
        rb_exec_fail(eargp, err, errmsg);
        RB_GC_GUARD(execarg_obj);
        rb_syserr_fail_str(err, fail_str);
    }
#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
    return PIDT2NUM(pid);
#else
    return Qnil;
#endif
}

times → process_tms 点击切换源代码

返回一个 Process::Tms 结构，其中包含当前进程及其子进程的用户和系统 CPU 时间

Process.times
# => #<struct Process::Tms utime=55.122118, stime=35.533068, cutime=0.0, cstime=0.002846>

精度由平台定义。

VALUE
rb_proc_times(VALUE obj)
{
    VALUE utime, stime, cutime, cstime, ret;
#if defined(RUSAGE_SELF) && defined(RUSAGE_CHILDREN)
    struct rusage usage_s, usage_c;

    if (getrusage(RUSAGE_SELF, &usage_s) != 0 || getrusage(RUSAGE_CHILDREN, &usage_c) != 0)
        rb_sys_fail("getrusage");
    utime = DBL2NUM((double)usage_s.ru_utime.tv_sec + (double)usage_s.ru_utime.tv_usec/1e6);
    stime = DBL2NUM((double)usage_s.ru_stime.tv_sec + (double)usage_s.ru_stime.tv_usec/1e6);
    cutime = DBL2NUM((double)usage_c.ru_utime.tv_sec + (double)usage_c.ru_utime.tv_usec/1e6);
    cstime = DBL2NUM((double)usage_c.ru_stime.tv_sec + (double)usage_c.ru_stime.tv_usec/1e6);
#else
    const double hertz = (double)get_clk_tck();
    struct tms buf;

    times(&buf);
    utime = DBL2NUM(buf.tms_utime / hertz);
    stime = DBL2NUM(buf.tms_stime / hertz);
    cutime = DBL2NUM(buf.tms_cutime / hertz);
    cstime = DBL2NUM(buf.tms_cstime / hertz);
#endif
    ret = rb_struct_new(rb_cProcessTms, utime, stime, cutime, cstime);
    RB_GC_GUARD(utime);
    RB_GC_GUARD(stime);
    RB_GC_GUARD(cutime);
    RB_GC_GUARD(cstime);
    return ret;
}

uid → integer 点击切换源代码

Process::UID.rid → integer

Process::Sys.getuid → integer

返回当前进程的（真实）用户 ID。

Process.uid # => 1000

static VALUE
proc_getuid(VALUE obj)
{
    rb_uid_t uid = getuid();
    return UIDT2NUM(uid);
}

uid = new_uid → new_uid 点击切换源代码

将当前进程的（用户）用户 ID 设置为 new_uid

Process.uid = 1000 # => 1000

并非所有平台都可用。

static VALUE
proc_setuid(VALUE obj, VALUE id)
{
    rb_uid_t uid;

    check_uid_switch();

    uid = OBJ2UID(id);
#if defined(HAVE_SETRESUID)
    if (setresuid(uid, -1, -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETREUID
    if (setreuid(uid, -1) < 0) rb_sys_fail(0);
#elif defined HAVE_SETRUID
    if (setruid(uid) < 0) rb_sys_fail(0);
#elif defined HAVE_SETUID
    {
        if (geteuid() == uid) {
            if (setuid(uid) < 0) rb_sys_fail(0);
        }
        else {
            rb_notimplement();
        }
    }
#endif
    return id;
}

wait(pid = -1, flags = 0) → integer 点击切换源代码

等待合适的子进程退出，返回其进程 ID，并将 $? 设置为一个包含该进程信息的 Process::Status 对象。等待哪个子进程取决于给定 pid 的值。

正整数：等待进程 ID 为 pid 的子进程。

pid0 = Process.spawn('ruby', '-e', 'exit 13') # => 230866
pid1 = Process.spawn('ruby', '-e', 'exit 14') # => 230891
Process.wait(pid0)                            # => 230866
$?                                            # => #<Process::Status: pid 230866 exit 13>
Process.wait(pid1)                            # => 230891
$?                                            # => #<Process::Status: pid 230891 exit 14>
Process.wait(pid0)                            # Raises Errno::ECHILD

0：等待任何组 ID 与当前进程相同的子进程。

parent_pgpid = Process.getpgid(Process.pid)
puts "Parent process group ID is #{parent_pgpid}."
child0_pid = fork do
  puts "Child 0 pid is #{Process.pid}"
  child0_pgid = Process.getpgid(Process.pid)
  puts "Child 0 process group ID is #{child0_pgid} (same as parent's)."
end
child1_pid = fork do
  puts "Child 1 pid is #{Process.pid}"
  Process.setpgid(0, Process.pid)
  child1_pgid = Process.getpgid(Process.pid)
  puts "Child 1 process group ID is #{child1_pgid} (different from parent's)."
end
retrieved_pid = Process.wait(0)
puts "Process.wait(0) returned pid #{retrieved_pid}, which is child 0 pid."
begin
  Process.wait(0)
rescue Errno::ECHILD => x
  puts "Raised #{x.class}, because child 1 process group ID differs from parent process group ID."
end

输出

Parent process group ID is 225764.
Child 0 pid is 225788
Child 0 process group ID is 225764 (same as parent's).
Child 1 pid is 225789
Child 1 process group ID is 225789 (different from parent's).
Process.wait(0) returned pid 225788, which is child 0 pid.
Raised Errno::ECHILD, because child 1 process group ID differs from parent process group ID.

-1（默认）：等待任何子进程。

parent_pgpid = Process.getpgid(Process.pid)
puts "Parent process group ID is #{parent_pgpid}."
child0_pid = fork do
  puts "Child 0 pid is #{Process.pid}"
  child0_pgid = Process.getpgid(Process.pid)
  puts "Child 0 process group ID is #{child0_pgid} (same as parent's)."
end
child1_pid = fork do
  puts "Child 1 pid is #{Process.pid}"
  Process.setpgid(0, Process.pid)
  child1_pgid = Process.getpgid(Process.pid)
  puts "Child 1 process group ID is #{child1_pgid} (different from parent's)."
  sleep 3 # To force child 1 to exit later than child 0 exit.
end
child_pids = [child0_pid, child1_pid]
retrieved_pid = Process.wait(-1)
puts child_pids.include?(retrieved_pid)
retrieved_pid = Process.wait(-1)
puts child_pids.include?(retrieved_pid)

输出

Parent process group ID is 228736.
Child 0 pid is 228758
Child 0 process group ID is 228736 (same as parent's).
Child 1 pid is 228759
Child 1 process group ID is 228759 (different from parent's).
true
true

小于 -1：等待任何进程组 ID 为 -pid 的子进程。

parent_pgpid = Process.getpgid(Process.pid)
puts "Parent process group ID is #{parent_pgpid}."
child0_pid = fork do
  puts "Child 0 pid is #{Process.pid}"
  child0_pgid = Process.getpgid(Process.pid)
  puts "Child 0 process group ID is #{child0_pgid} (same as parent's)."
end
child1_pid = fork do
  puts "Child 1 pid is #{Process.pid}"
  Process.setpgid(0, Process.pid)
  child1_pgid = Process.getpgid(Process.pid)
  puts "Child 1 process group ID is #{child1_pgid} (different from parent's)."
end
sleep 1
retrieved_pid = Process.wait(-child1_pid)
puts "Process.wait(-child1_pid) returned pid #{retrieved_pid}, which is child 1 pid."
begin
  Process.wait(-child1_pid)
rescue Errno::ECHILD => x
  puts "Raised #{x.class}, because there's no longer a child with process group id #{child1_pid}."
end

输出

Parent process group ID is 230083.
Child 0 pid is 230108
Child 0 process group ID is 230083 (same as parent's).
Child 1 pid is 230109
Child 1 process group ID is 230109 (different from parent's).
Process.wait(-child1_pid) returned pid 230109, which is child 1 pid.
Raised Errno::ECHILD, because there's no longer a child with process group id 230109.

参数 flags 应作为以下常量之一给出，或作为两者的逻辑 OR。

Process::WNOHANG：如果没有任何子进程可用，则不阻塞。
Process:WUNTRACED：可能会返回一个已停止的子进程，即使尚未报告。

并非所有平台都支持所有标志。

如果没有任何合适的子进程，则引发 Errno::ECHILD。

并非所有平台都可用。

Process.waitpid 是 Process.wait 的别名。

static VALUE
proc_m_wait(int c, VALUE *v, VALUE _)
{
    return proc_wait(c, v);
}

wait2(pid = -1, flags = 0) → [pid, status] 点击切换源代码

与 Process.waitpid 相似，但返回一个包含子进程 pid 和 Process::Status status 的数组。

pid = Process.spawn('ruby', '-e', 'exit 13') # => 309581
Process.wait2(pid)
# => [309581, #<Process::Status: pid 309581 exit 13>]

Process.waitpid2 是 Process.waitpid 的别名。

static VALUE
proc_wait2(int argc, VALUE *argv, VALUE _)
{
    VALUE pid = proc_wait(argc, argv);
    if (NIL_P(pid)) return Qnil;
    return rb_assoc_new(pid, rb_last_status_get());
}

waitall → array 点击切换源代码

等待所有子进程，返回一个包含 2 个元素数组的数组；每个子数组包含一个已回收子进程的整数 pid 和 Process::Status 状态。

pid0 = Process.spawn('ruby', '-e', 'exit 13') # => 325470
pid1 = Process.spawn('ruby', '-e', 'exit 14') # => 325495
Process.waitall
# => [[325470, #<Process::Status: pid 325470 exit 13>], [325495, #<Process::Status: pid 325495 exit 14>]]

static VALUE
proc_waitall(VALUE _)
{
    VALUE result;
    rb_pid_t pid;
    int status;

    result = rb_ary_new();
    rb_last_status_clear();

    for (pid = -1;;) {
        pid = rb_waitpid(-1, &status, 0);
        if (pid == -1) {
            int e = errno;
            if (e == ECHILD)
                break;
            rb_syserr_fail(e, 0);
        }
        rb_ary_push(result, rb_assoc_new(PIDT2NUM(pid), rb_last_status_get()));
    }
    return result;
}

wait(pid = -1, flags = 0) → integer 点击切换源代码

等待合适的子进程退出，返回其进程 ID，并将 $? 设置为一个包含该进程信息的 Process::Status 对象。等待哪个子进程取决于给定 pid 的值。

正整数：等待进程 ID 为 pid 的子进程。

pid0 = Process.spawn('ruby', '-e', 'exit 13') # => 230866
pid1 = Process.spawn('ruby', '-e', 'exit 14') # => 230891
Process.wait(pid0)                            # => 230866
$?                                            # => #<Process::Status: pid 230866 exit 13>
Process.wait(pid1)                            # => 230891
$?                                            # => #<Process::Status: pid 230891 exit 14>
Process.wait(pid0)                            # Raises Errno::ECHILD

0：等待任何组 ID 与当前进程相同的子进程。

parent_pgpid = Process.getpgid(Process.pid)
puts "Parent process group ID is #{parent_pgpid}."
child0_pid = fork do
  puts "Child 0 pid is #{Process.pid}"
  child0_pgid = Process.getpgid(Process.pid)
  puts "Child 0 process group ID is #{child0_pgid} (same as parent's)."
end
child1_pid = fork do
  puts "Child 1 pid is #{Process.pid}"
  Process.setpgid(0, Process.pid)
  child1_pgid = Process.getpgid(Process.pid)
  puts "Child 1 process group ID is #{child1_pgid} (different from parent's)."
end
retrieved_pid = Process.wait(0)
puts "Process.wait(0) returned pid #{retrieved_pid}, which is child 0 pid."
begin
  Process.wait(0)
rescue Errno::ECHILD => x
  puts "Raised #{x.class}, because child 1 process group ID differs from parent process group ID."
end

输出

Parent process group ID is 225764.
Child 0 pid is 225788
Child 0 process group ID is 225764 (same as parent's).
Child 1 pid is 225789
Child 1 process group ID is 225789 (different from parent's).
Process.wait(0) returned pid 225788, which is child 0 pid.
Raised Errno::ECHILD, because child 1 process group ID differs from parent process group ID.

-1（默认）：等待任何子进程。

parent_pgpid = Process.getpgid(Process.pid)
puts "Parent process group ID is #{parent_pgpid}."
child0_pid = fork do
  puts "Child 0 pid is #{Process.pid}"
  child0_pgid = Process.getpgid(Process.pid)
  puts "Child 0 process group ID is #{child0_pgid} (same as parent's)."
end
child1_pid = fork do
  puts "Child 1 pid is #{Process.pid}"
  Process.setpgid(0, Process.pid)
  child1_pgid = Process.getpgid(Process.pid)
  puts "Child 1 process group ID is #{child1_pgid} (different from parent's)."
  sleep 3 # To force child 1 to exit later than child 0 exit.
end
child_pids = [child0_pid, child1_pid]
retrieved_pid = Process.wait(-1)
puts child_pids.include?(retrieved_pid)
retrieved_pid = Process.wait(-1)
puts child_pids.include?(retrieved_pid)

输出

Parent process group ID is 228736.
Child 0 pid is 228758
Child 0 process group ID is 228736 (same as parent's).
Child 1 pid is 228759
Child 1 process group ID is 228759 (different from parent's).
true
true

小于 -1：等待任何进程组 ID 为 -pid 的子进程。

parent_pgpid = Process.getpgid(Process.pid)
puts "Parent process group ID is #{parent_pgpid}."
child0_pid = fork do
  puts "Child 0 pid is #{Process.pid}"
  child0_pgid = Process.getpgid(Process.pid)
  puts "Child 0 process group ID is #{child0_pgid} (same as parent's)."
end
child1_pid = fork do
  puts "Child 1 pid is #{Process.pid}"
  Process.setpgid(0, Process.pid)
  child1_pgid = Process.getpgid(Process.pid)
  puts "Child 1 process group ID is #{child1_pgid} (different from parent's)."
end
sleep 1
retrieved_pid = Process.wait(-child1_pid)
puts "Process.wait(-child1_pid) returned pid #{retrieved_pid}, which is child 1 pid."
begin
  Process.wait(-child1_pid)
rescue Errno::ECHILD => x
  puts "Raised #{x.class}, because there's no longer a child with process group id #{child1_pid}."
end

输出

Parent process group ID is 230083.
Child 0 pid is 230108
Child 0 process group ID is 230083 (same as parent's).
Child 1 pid is 230109
Child 1 process group ID is 230109 (different from parent's).
Process.wait(-child1_pid) returned pid 230109, which is child 1 pid.
Raised Errno::ECHILD, because there's no longer a child with process group id 230109.

参数 flags 应作为以下常量之一给出，或作为两者的逻辑 OR。

Process::WNOHANG：如果没有任何子进程可用，则不阻塞。
Process:WUNTRACED：可能会返回一个已停止的子进程，即使尚未报告。

并非所有平台都支持所有标志。

如果没有任何合适的子进程，则引发 Errno::ECHILD。

并非所有平台都可用。

Process.waitpid 是 Process.wait 的别名。

static VALUE
proc_m_wait(int c, VALUE *v, VALUE _)
{
    return proc_wait(c, v);
}

wait2(pid = -1, flags = 0) → [pid, status] 点击切换源代码

与 Process.waitpid 相似，但返回一个包含子进程 pid 和 Process::Status status 的数组。

pid = Process.spawn('ruby', '-e', 'exit 13') # => 309581
Process.wait2(pid)
# => [309581, #<Process::Status: pid 309581 exit 13>]

Process.waitpid2 是 Process.waitpid 的别名。

static VALUE
proc_wait2(int argc, VALUE *argv, VALUE _)
{
    VALUE pid = proc_wait(argc, argv);
    if (NIL_P(pid)) return Qnil;
    return rb_assoc_new(pid, rb_last_status_get());
}

warmup → true 点击切换源代码

通知 Ruby 虚拟机引导序列已完成，现在是优化应用程序的最佳时机。这对长时间运行的应用程序很有用。

此方法应在应用程序引导结束时调用。如果应用程序使用预分叉模型部署，则应在第一次分叉之前在原始进程中调用 Process.warmup。

执行的实际优化完全取决于实现，并且将来可能会在未经通知的情况下更改。

在 CRuby 中，Process.warmup

执行一次主要的 GC。
压缩堆。
将所有存活对象提升到老年代。
预先计算所有字符串的编码范围。
释放所有空闲堆页，并将可分配页计数器增加释放的页数。
如果可用，调用 malloc_trim 来释放空闲的 malloc 页。

static VALUE
proc_warmup(VALUE _)
{
    RB_VM_LOCK_ENTER();
    rb_gc_prepare_heap();
    RB_VM_LOCK_LEAVE();
    return Qtrue;
}

模块 Process

进程创建¶ ↑

执行环境¶ ↑

参数 command_line 或 exe_path¶ ↑

执行选项¶ ↑

工作目录 (:chdir)¶ ↑

文件重定向（文件描述符）¶ ↑

环境变量 (:unsetenv_others)¶ ↑

文件创建访问 (:umask)¶ ↑

进程组 (:pgroup 和 :new_pgroup)¶ ↑

资源限制¶ ↑

文件描述符继承¶ ↑

执行 Shell¶ ↑

这里有什么¶ ↑

当前进程获取器¶ ↑

当前进程设置器¶ ↑

当前进程执行¶ ↑

子进程¶ ↑

进程组¶ ↑

计时¶ ↑

参数 `command_line` 或 `exe_path`¶ ↑

工作目录 (`:chdir`)¶ ↑

环境变量 (`:unsetenv_others`)¶ ↑

文件创建访问 (`:umask`)¶ ↑

进程组 (`:pgroup` 和 `:new_pgroup`)¶ ↑