模块 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 保留字或特殊内置字开头,或者包含一个或多个元字符,则为command_line
。 -
否则为
exe_path
。
参数 command_line
¶ ↑
字符串参数 command_line
是要传递给 shell 的命令行;它必须以 shell 保留字开头,以特殊内置字开头,或者包含元字符
system('if true; then echo "Foo"; fi') # => true # Shell reserved word. system('exit') # => 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
是以下之一
-
要调用的可执行文件的字符串路径
示例
system('/usr/bin/date') # => true # Path to date on Unix-style system. system('foo') # => nil # Command execlution failed.
输出
Thu Aug 31 10:06:48 AM CDT 2023
不带参数且包含空格的路径或命令名称无法与上面的
command_line
区分开来,因此您必须以平台相关的方式使用 shell 引号或转义整个命令名称,或者使用下面的数组形式。如果
exe_path
不包含任何路径分隔符,则会从PATH
环境变量指定的目录中搜索可执行文件。此处“可执行”一词的含义取决于平台。即使该文件被认为是“可执行”的,其内容也可能不是正确的执行格式。在这种情况下,Ruby 会尝试在类 Unix 系统上使用
/bin/sh
运行它,就像 system(3) 所做的那样。File.write('shell_command', 'echo $SHELL', perm: 0o755) system('./shell_command') # prints "/bin/sh" or something.
-
包含可执行文件的路径和要用作执行进程名称的字符串的 2 元素数组
示例
pid = spawn(['sleep', 'Hello!'], '1') # 2-element array. p `ps -p #{pid} -o command=`
输出
"Hello! 1\n"
参数 args
¶ ↑
如果 command_line
不包含空格和制表符之外的 shell 元字符,或者给出了 exe_path
,则 Ruby 会直接调用可执行文件。此形式不使用 shell
spawn("doesnt_exist") # Raises Errno::ENOENT spawn("doesnt_exist", "\n") # Raises Errno::ENOENT spawn("doesnt_exist\n") # => false # sh: 1: doesnot_exist: not found
错误消息来自 shell,并且会因您的系统而异。
如果在 exe_path
之后给出一个或多个 args
,则每个参数都是要传递给可执行文件的参数或选项
示例
system('echo', '<', 'C*', '|', '$SHELL', '>') # => true
输出
< C* | $SHELL >
但是,在 Windows 上有一些例外。请参阅 Windows 上的执行 Shell。
如果您想调用不带 shell 的包含空格的路径,您将需要使用一个 2 元素数组 exe_path
。
示例
path = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome' spawn(path) # Raises Errno::ENOENT; No such file or directory - /Applications/Google spawn([path] * 2)
执行选项¶ ↑
可选的尾随参数 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
的文件,其中mode
对于源:in
为'r'
,对于源:out
或:err
为'w'
。 -
[filepath]
:通过open(filepath, 'r', 0644)
从filepath
的文件重定向。 -
[filepath, mode]
:通过open(filepath, mode, 0644)
从或重定向到filepath
的文件。 -
[filepath, mode, perm]
:通过open(filepath, mode, perm)
从或重定向到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)
输出
0644
进程组 (:pgroup
和 :new_pgroup
)¶ ↑
默认情况下,新进程与父进程属于同一个 进程组。
要指定不同的进程组。使用以下值之一的执行选项 :pgroup
-
true
:为新进程创建一个新的进程组。 -
pgid:在新进程组中创建新进程,其 id 为 pgid。
仅在 Windows 上,使用值为 true
的执行选项 :new_pgroup
为新进程创建一个新的进程组。
资源限制¶ ↑
使用执行选项设置资源限制。
这些选项的键是 :rlimit_resource_name
形式的符号,其中 resource_name 是方法 Process.setrlimit
中描述的字符串资源名称的小写形式。例如,键 :rlimit_cpu
对应于资源限制 'CPU'
。
此类键的值是以下之一
-
一个整数,指定当前和最大限制。
-
一个包含整数的 2 元素数组,指定当前和最大限制。
文件描述符继承¶ ↑
默认情况下,新进程从父进程继承文件描述符。
使用执行选项 :close_others => true
通过关闭未以其他方式重定向的非标准 fd(3 及更高版本)来修改该继承。
执行 Shell¶ ↑
在类 Unix 系统上,调用的 shell 是 /bin/sh
;整个字符串 command_line
作为参数传递给 shell 选项 -c。
shell 对命令行执行正常的 shell 扩展
示例
system('echo $SHELL: C*') # => true
输出
/bin/bash: CONTRIBUTING.md COPYING COPYING.ja
Windows 上的执行 Shell¶ ↑
在 Windows 上,调用的 shell 由环境变量 RUBYSHELL
(如果已定义)或 COMSPEC
(否则)确定;整个字符串 command_line
作为参数传递给 RUBYSHELL
的 -c
选项,以及 /bin/sh
,以及 COMSPEC
的 /c 选项。在以下情况下,shell 会自动调用:
-
该命令是
cmd.exe
的内置命令,例如echo
。 -
可执行文件是一个批处理文件;其名称以
.bat
或.cmd
结尾。
请注意,即使以 exe_path
形式调用,该命令仍将以 command_line
形式调用,因为 cmd.exe
不接受像 /bin/sh
这样的脚本名称,而只适用于 /c
选项。
标准 shell cmd.exe
执行环境变量扩展,但不具备 globbing 功能
示例
system("echo %COMSPEC%: C*")' # => true
输出
C:\WINDOWS\system32\cmd.exe: C*
本节内容¶ ↑
当前进程 Getter¶ ↑
-
::argv0
: 返回进程名称,作为冻结字符串。 -
::egid
: 返回有效组 ID。 -
::euid
: 返回有效用户 ID。 -
::getpgrp
: 返回进程组 ID。 -
::getrlimit
: 返回资源限制。 -
::gid
: 返回(真实)组 ID。 -
::pid
: 返回进程 ID。 -
::ppid
: 返回父进程的进程 ID。 -
::uid
: 返回(真实)用户 ID。
当前进程 Setter¶ ↑
-
::egid=
: 设置有效组 ID。 -
::euid=
: 设置有效用户 ID。 -
::gid=
: 设置(真实)组 ID。 -
::setproctitle
: 设置进程标题。 -
::setpgrp
: 将进程的进程组 ID 设置为零。 -
::setrlimit
: 设置资源限制。 -
::setsid
: 将进程建立为新的会话和进程组领导者,没有控制 tty。 -
::uid=
: 设置用户 ID。
当前进程执行¶ ↑
-
::abort
: 立即终止进程。 -
::daemon
: 将进程与其控制终端分离,并在后台作为系统守护进程继续运行。 -
::exec
: 通过运行给定的外部命令替换进程。 -
::exit
: 通过引发异常SystemExit
(可以捕获)启动进程终止。 -
::exit!
: 立即退出进程。 -
::warmup
: 通知 Ruby 虚拟机应用程序的启动序列已完成,并且 VM 可以开始优化应用程序。
子进程¶ ↑
-
::detach
: 防止子进程成为僵尸进程。 -
::fork
: 创建子进程。 -
::kill
: 向进程发送给定的信号。 -
::spawn
: 创建子进程。 -
::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
- CLOCK_BOOTTIME_ALARM
- CLOCK_MONOTONIC
- CLOCK_MONOTONIC_COARSE
- CLOCK_MONOTONIC_FAST
- CLOCK_MONOTONIC_PRECISE
- CLOCK_MONOTONIC_RAW
- CLOCK_MONOTONIC_RAW_APPROX
- CLOCK_PROCESS_CPUTIME_ID
- CLOCK_PROF
- CLOCK_REALTIME
- CLOCK_REALTIME_ALARM
- CLOCK_REALTIME_COARSE
- CLOCK_REALTIME_FAST
- CLOCK_REALTIME_PRECISE
- CLOCK_SECOND
- CLOCK_TAI
- CLOCK_THREAD_CPUTIME_ID
- CLOCK_UPTIME
- CLOCK_UPTIME_FAST
- CLOCK_UPTIME_PRECISE
- CLOCK_UPTIME_RAW
- CLOCK_UPTIME_RAW_APPROX
- CLOCK_VIRTUAL
- PRIO_PGRP
- PRIO_PROCESS
- PRIO_USER
- 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
- RLIM_SAVED_CUR
- RLIM_SAVED_MAX
- WNOHANG
-
请参阅
Process.wait
- WUNTRACED
-
请参阅
Process.wait
公共类方法
来源
VALUE rb_proc__fork(VALUE _obj) { rb_pid_t pid = proc_fork_pid(); return PIDT2NUM(pid); }
fork 的内部 API。请勿直接调用此方法。目前,通过 Kernel#fork
、Process.fork
和使用 "-"
的 IO.popen
调用此方法。
此方法不是用于随意代码,而是用于应用程序监视库。您可以通过重写此方法在 fork 事件之前和之后添加自定义代码。
注意:Process.daemon
可能使用 fork(2) 实现,但不会通过此方法。因此,根据您连接到此方法的原因,您可能还想连接到该方法。有关此的更详细讨论,请参阅 此问题。
来源
static VALUE f_abort(int c, const VALUE *a, VALUE _) { rb_f_abort(c, a); UNREACHABLE_RETURN(Qnil); }
通过调用 Kernel.exit(false)
立即终止执行。
如果给出了字符串参数 msg
,则在终止之前将其写入 STDERR;否则,如果引发了异常,则打印其消息和回溯。
来源
static VALUE proc_argv0(VALUE process) { return rb_orig_progname; }
返回正在执行的脚本的名称。该值不受为 $0 分配新值的影响。
此方法首次出现在 Ruby 2.1 中,作为获取脚本名称的无全局变量手段。
来源
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); } }
返回由 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_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); }
返回由 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 代表 Single Unix Specification(单一 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
:使用 mach_absolute_time(),在 Darwin 上可用。分辨率取决于 CPU。 -
:TIMES_BASED_CLOCK_MONOTONIC
:使用 POSIX 定义的 times() 的结果值,因此成功完成后,times() 应返回自过去任意时间点(例如,系统启动时间)以来经过的实际时间,以时钟滴答为单位。
例如,GNU/Linux 返回一个基于节拍的值,并且它是单调的。但是,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
() 返回纳秒数。 Float
对象 (IEEE 754 双精度) 不足以表示 :CLOCK_REALTIME
的返回值。如果需要确切的纳秒值,请使用 :nanosecond
作为 unit
。
返回值的原点(时间零)取决于系统,例如,可能是系统启动时间、进程启动时间、Epoch 等。
:CLOCK_REALTIME
中的原点定义为 Epoch:1970-01-01 00:00:00 UTC
;某些系统计算闰秒,而另一些系统则不计算,因此结果可能因系统而异。
来源
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); }
将当前进程从其控制终端分离,并在后台作为系统守护进程运行;返回零。
默认情况下
-
将当前工作目录更改为根目录。
-
将 $stdin、$stdout 和 $stderr 重定向到空设备。
如果可选参数 nochdir
为 true
,则不更改当前工作目录。
如果可选参数 noclose
为 true
,则不重定向 $stdin、$stdout 或 $stderr。
来源
static VALUE proc_detach(VALUE obj, VALUE pid) { return rb_detach_process(NUM2PIDT(pid)); }
避免子进程成为僵尸进程的可能性。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_getegid(VALUE obj) { rb_gid_t egid = getegid(); return GIDT2NUM(egid); }
返回当前进程的有效组 ID
Process.egid # => 500
并非在所有平台上都可用。
来源
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; }
设置当前进程的有效组 ID。
并非在所有平台上都可用。
来源
static VALUE proc_geteuid(VALUE obj) { rb_uid_t euid = geteuid(); return UIDT2NUM(euid); }
返回当前进程的有效用户 ID。
Process.euid # => 501
来源
static VALUE proc_seteuid_m(VALUE mod, VALUE euid) { check_uid_switch(); proc_seteuid(OBJ2UID(euid)); return euid; }
设置当前进程的有效用户 ID。
并非在所有平台上都可用。
来源
static VALUE f_exec(int c, const VALUE *a, VALUE _) { rb_f_exec(c, a); UNREACHABLE_RETURN(Qnil); }
通过执行以下操作之一来替换当前进程
-
将字符串
command_line
传递给 shell。 -
调用
exe_path
处的执行文件。
如果使用不受信任的输入调用此方法,则存在潜在的安全漏洞;请参阅命令注入。
新进程是使用 exec 系统调用创建的;它可能会从调用程序继承其部分环境(可能包括打开的文件描述符)。
如果给定参数 env
,它是一个影响新进程的 ENV
的哈希;请参阅 执行环境。
参数 options
是新进程的选项哈希;请参阅 执行选项。
第一个必需的参数是以下之一
-
如果
command_line
是字符串,并且如果它以 shell 保留字或特殊内置命令开头,或者如果它包含一个或多个元字符,则为command_line
。 -
否则为
exe_path
。
参数 command_line
字符串参数 command_line
是要传递给 shell 的命令行;它必须以 shell 保留字开头,以特殊内置字开头,或者包含元字符
exec('if true; then echo "Foo"; fi') # Shell reserved word. exec('exit') # Built-in. exec('date > date.tmp') # Contains meta character.
命令行还可以包含命令的参数和选项
exec('echo "Foo"')
输出
Foo
有关 shell 的详细信息,请参阅 执行 Shell。
如果新进程无法执行,则会引发异常。
参数 exe_path
参数 exe_path
是以下之一
-
要调用的可执行文件的字符串路径。
-
包含可执行文件的路径和要用作执行进程名称的字符串的 2 元素数组。
示例
exec('/usr/bin/date')
输出
Sat Aug 26 09:38:00 AM CDT 2023
Ruby 直接调用可执行文件。此形式不使用 shell;请参阅 参数 args 了解注意事项。
exec('doesnt_exist') # Raises Errno::ENOENT
如果给定了一个或多个 args
,则每个都是要传递给可执行文件的参数或选项
exec('echo', 'C*') exec('echo', 'hello', 'world')
输出
C* hello world
如果新进程无法执行,则会引发异常。
来源
static VALUE f_exit(int c, const VALUE *a, VALUE _) { rb_f_exit(c, a); UNREACHABLE_RETURN(Qnil); }
通过引发 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 会执行任何 at-exit 过程(请参阅 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 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); }
立即退出进程;不会调用任何退出处理程序。将退出状态 status
返回到底层操作系统。
Process.exit!(true)
参数 status
的值 true
和 false
分别表示成功和失败;整数值的含义取决于系统。
来源
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); }
创建子进程。
如果给定了块,则在子进程中运行该块;在块退出时,子进程以状态零终止
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 proc_getpgid(VALUE obj, VALUE pid) { rb_pid_t i; i = getpgid(NUM2PIDT(pid)); if (i < 0) rb_sys_fail(0); return PIDT2NUM(i); }
Returns the process group ID for the given process ID +pid+: Process.getpgid(Process.ppid) # => 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 }
返回当前进程的进程组 ID
Process.getpgid(0) # => 25527 Process.getpgrp # => 25527
来源
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); }
返回指定进程、进程组或用户的调度优先级。
参数 kind
是以下之一
-
Process::PRIO_PROCESS
:返回进程的优先级。 -
Process::PRIO_PGRP
:返回进程组的优先级。 -
Process::PRIO_USER
:返回用户的优先级。
参数 id
是进程、进程组或用户的 ID;零表示 kind
的当前 ID。
示例
Process.getpriority(Process::PRIO_USER, 0) # => 19 Process.getpriority(Process::PRIO_PROCESS, 0) # => 19
并非在所有平台上都可用。
来源
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)); }
返回一个包含当前(软)限制和给定 resource
的最大(硬)限制的 2 元素数组。
参数 resource
指定要返回其限制的资源;请参阅 Process.setrlimit
。
返回的每个值 cur_limit
和 max_limit
都是一个整数;请参阅 Process.setrlimit
。
示例
Process.getrlimit(:CORE) # => [0, 18446744073709551615]
请参阅 Process.setrlimit
。
并非在所有平台上都可用。
来源
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); }
返回给定进程 ID pid
的会话 ID,如果未给定,则返回当前进程的会话 ID
Process.getsid # => 27422 Process.getsid(0) # => 27422 Process.getsid(Process.pid()) # => 27422
并非在所有平台上都可用。
来源
static VALUE proc_getgid(VALUE obj) { rb_gid_t gid = getgid(); return GIDT2NUM(gid); }
返回当前进程的(真实)组 ID
Process.gid # => 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); }
将当前进程的组 ID 设置为 new_gid
Process.gid = 1000 # => 1000
来源
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; }
返回当前进程补充组访问列表中的组 ID 数组
Process.groups # => [4, 24, 27, 30, 46, 122, 135, 136, 1000]
返回的数组的这些属性是系统相关的
-
数组是否(以及如何)排序。
-
数组是否包含有效组 ID。
-
数组是否包含重复的组 ID。
-
数组大小是否超过
Process.maxgroups
的值。
使用此调用获取已排序且唯一的数组
Process.groups.uniq.sort
来源
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); }
将补充组访问列表设置为给定的组 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_initgroups(VALUE obj, VALUE uname, VALUE base_grp) { if (initgroups(StringValueCStr(uname), OBJ2GID(base_grp)) != 0) { rb_sys_fail(0); } return proc_getgroups(obj); }
设置补充组访问列表;新列表包括
-
由
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_rb_f_kill(int c, const VALUE *v, VALUE _) { return rb_f_kill(c, v); }
向由 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_s_last_status(VALUE mod) { return rb_last_status_get(); }
返回一个 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_getmaxgroups(VALUE obj) { return INT2FIX(maxgroups()); }
返回补充组访问列表中允许的最大组 ID 数
Process.maxgroups # => 32
来源
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); }
设置补充组访问列表中允许的最大组 ID 数。
来源
static VALUE proc_get_pid(VALUE _) { return get_pid(); }
返回当前进程的进程 ID
Process.pid # => 15668
来源
static VALUE proc_get_ppid(VALUE _) { return get_ppid(); }
返回当前进程的父进程的进程 ID
puts "Pid is #{Process.pid}." fork { puts "Parent pid is #{Process.ppid}." }
输出
Pid is 271290. Parent pid is 271290.
在某些平台上可能不会返回可信任的值。
来源
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); }
将由进程 ID pid
给定的进程的进程组 ID 设置为 pgid
。
并非在所有平台上都可用。
来源
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); }
等效于 setpgid(0, 0)
。
并非在所有平台上都可用。
来源
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); }
请参阅 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_setproctitle(VALUE process, VALUE title) { return ruby_setproctitle(title); }
设置在 ps(1) 命令上显示的进程标题。不一定在所有平台上都有效。无论结果如何,都不会引发异常,即使平台不支持该功能,也不会引发 NotImplementedError
。
调用此方法不会影响 $0 的值。
Process.setproctitle('myapp: worker #%d' % worker_id)
此方法首次出现在 Ruby 2.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; }
将给定 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 时间(微秒)(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_setsid(VALUE _) { rb_pid_t pid; pid = setsid(); if (pid < 0) rb_sys_fail(0); return PIDT2NUM(pid); }
将当前进程建立为新的会话和进程组领导者,没有控制 tty;返回会话 ID
Process.setsid # => 27422
并非在所有平台上都可用。
来源
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 }
通过在该进程中执行以下操作之一来创建新的子进程
-
将字符串
command_line
传递给 shell。 -
调用
exe_path
处的执行文件。
如果使用不受信任的输入调用此方法,则存在潜在的安全漏洞;请参阅命令注入。
返回新进程的进程 ID (pid),而不等待其完成。
为了避免僵尸进程,父进程应该调用以下两者之一
-
Process.wait
,来收集其子进程的终止状态。 -
Process.detach
,来表示对其状态不感兴趣。
新进程是使用 exec 系统调用创建的;它可能会从调用程序继承其部分环境(可能包括打开的文件描述符)。
如果给定参数 env
,它是一个影响新进程的 ENV
的哈希;请参阅 执行环境。
参数 options
是新进程的选项哈希;请参阅 执行选项。
第一个必需的参数是以下之一
-
如果
command_line
是字符串,并且如果它以 shell 保留字或特殊内置命令开头,或者如果它包含一个或多个元字符,则为command_line
。 -
否则为
exe_path
。
参数 command_line
字符串参数 command_line
是要传递给 shell 的命令行;它必须以 shell 保留字开头,以特殊内置字开头,或者包含元字符
spawn('if true; then echo "Foo"; fi') # => 798847 # Shell reserved word. Process.wait # => 798847 spawn('exit') # => 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
是以下之一
-
要调用的可执行文件的字符串路径。
-
一个包含要调用的可执行文件路径和要用作执行进程名称的字符串的 2 元素数组。
spawn('/usr/bin/date') # Path to date on Unix-style system. Process.wait
输出
Mon Aug 28 11:43:10 AM CDT 2023
Ruby 直接调用可执行文件。此形式不使用 shell;请参阅 参数 args 了解注意事项。
如果给定了一个或多个 args
,则每个都是要传递给可执行文件的参数或选项
spawn('echo', 'C*') # => 799392 Process.wait # => 799392 spawn('echo', 'hello', 'world') # => 799393 Process.wait # => 799393
输出
C* hello world
如果新进程无法执行,则会引发异常。
来源
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; }
返回一个 Process::Tms
结构,该结构包含当前进程及其子进程的用户和系统 CPU 时间
Process.times # => #<struct Process::Tms utime=55.122118, stime=35.533068, cutime=0.0, cstime=0.002846>
精度是平台定义的。
来源
static VALUE proc_getuid(VALUE obj) { rb_uid_t uid = getuid(); return UIDT2NUM(uid); }
返回当前进程的(实际)用户 ID。
Process.uid # => 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; }
将当前进程的(用户)用户 ID 设置为 new_uid
Process.uid = 1000 # => 1000
并非在所有平台上都可用。
来源
static VALUE proc_m_wait(int c, VALUE *v, VALUE _) { return proc_wait(c, v); }
等待一个合适的子进程退出,返回其进程 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_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()); }
与 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.wait2
的别名。
来源
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; }
等待所有子进程,返回一个由包含 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_m_wait(int c, VALUE *v, VALUE _) { return proc_wait(c, v); }
等待一个合适的子进程退出,返回其进程 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_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()); }
与 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.wait2
的别名。
来源
static VALUE proc_warmup(VALUE _) { RB_VM_LOCK_ENTER(); rb_gc_prepare_heap(); RB_VM_LOCK_LEAVE(); return Qtrue; }
通知 Ruby 虚拟机引导序列已完成,现在是优化应用程序的好时机。这对于长时间运行的应用程序很有用。
此方法预计在应用程序引导结束时调用。如果应用程序是使用预分叉模型部署的,则 Process.warmup
应在第一次分叉之前的原始进程中调用。
实际执行的优化完全取决于实现,并且可能会在未来更改,恕不另行通知。
在 CRuby 上,Process.warmup
-
执行主要
GC
。 -
压缩堆。
-
将所有存活的对象提升到旧生代。
-
预先计算所有字符串的编码范围。
-
释放所有空的堆页,并将可分配的页计数器增加释放的页数。
-
如果可用,则调用
malloc_trim
以释放空的 malloc 页。