类 Fiber
Fiber 是在 Ruby 中实现轻量级协作并发的原语。 基本上，它们是一种创建可以暂停和恢复的代码块的方法，很像线程。 主要区别在于它们永远不会被抢占，并且调度必须由程序员完成，而不是由虚拟机完成。
与其他无栈轻量级并发模型相反，每个 fiber 都带有一个堆栈。 这使得 fiber 可以在 fiber 块内从深层嵌套的函数调用中暂停。 请参阅 ruby(1) 手册页以配置 fiber 堆栈的大小。
创建 fiber 时，它不会自动运行。 而是必须使用 Fiber#resume 方法显式请求运行。 在 fiber 内运行的代码可以通过调用 Fiber.yield 来放弃控制，在这种情况下，它会将控制权返回给调用者（Fiber#resume 的调用者）。
在 yield 或终止时，Fiber 返回最后执行的表达式的值
例如
fiber = Fiber.new do Fiber.yield 1 2 end puts fiber.resume puts fiber.resume puts fiber.resume
产生
1 2 FiberError: dead fiber called
Fiber#resume 方法接受任意数量的参数，如果是第一次调用 resume，它们将作为块参数传递。 否则，它们将是调用 Fiber.yield 的返回值
示例
fiber = Fiber.new do |first| second = Fiber.yield first + 2 end puts fiber.resume 10 puts fiber.resume 1_000_000 puts fiber.resume "The fiber will be dead before I can cause trouble"
产生
12 1000000 FiberError: dead fiber called
非阻塞 Fiber¶ ↑
非阻塞 fiber 的概念是在 Ruby 3.0 中引入的。 当一个非阻塞 fiber 遇到通常会阻塞 fiber 的操作（如 sleep 或等待另一个进程或 I/O）时，它会将控制权交给其他 fiber，并允许调度器处理阻塞并在可以继续时唤醒（恢复）此 fiber。
要使 Fiber 的行为像非阻塞 fiber，需要在 Fiber.new 中使用 blocking: false（这是默认值）创建，并且 Fiber.scheduler 应该使用 Fiber.set_scheduler 设置。 如果 Fiber.scheduler 未在当前线程中设置，则阻塞和非阻塞 fiber 的行为是相同的。
Ruby 不提供调度器类：它应该由用户实现，并对应于 Fiber::Scheduler。
还有一个 Fiber.schedule 方法，该方法应该立即以非阻塞方式执行给定的块。 其实际实现取决于调度器。
公共类方法
来源
static VALUE
rb_fiber_storage_aref(VALUE class, VALUE key)
{
key = rb_to_symbol(key);
VALUE storage = fiber_storage_get(fiber_current(), FALSE);
if (storage == Qnil) return Qnil;
return rb_hash_aref(storage, key);
}
返回由 key 标识的 fiber 存储变量的值。
key 必须是符号，并且该值由 Fiber#[]= 或 Fiber#store 设置。
另请参阅 Fiber::[]=。
来源
static VALUE
rb_fiber_storage_aset(VALUE class, VALUE key, VALUE value)
{
key = rb_to_symbol(key);
VALUE storage = fiber_storage_get(fiber_current(), value != Qnil);
if (storage == Qnil) return Qnil;
if (value == Qnil) {
return rb_hash_delete(storage, key);
}
else {
return rb_hash_aset(storage, key, value);
}
}
将 value 赋值给由 key 标识的 fiber 存储变量。 如果该变量不存在，则会创建它。
key 必须是 Symbol，否则会引发 TypeError。
另请参阅 Fiber::[]。
来源
VALUE
rb_fiber_blocking(VALUE class)
{
VALUE fiber_value = rb_fiber_current();
rb_fiber_t *fiber = fiber_ptr(fiber_value);
// If we are already blocking, this is essentially a no-op:
if (fiber->blocking) {
return rb_yield(fiber_value);
}
else {
return rb_ensure(fiber_blocking_yield, fiber_value, fiber_blocking_ensure, fiber_value);
}
}
强制 fiber 在块的持续时间内阻塞。 返回块的结果。
有关详细信息，请参阅类文档中的“非阻塞 fiber”部分。
来源
static VALUE
rb_fiber_s_blocking_p(VALUE klass)
{
rb_thread_t *thread = GET_THREAD();
unsigned blocking = thread->blocking;
if (blocking == 0)
return Qfalse;
return INT2NUM(blocking);
}
如果当前 fiber 是非阻塞的，则返回 false。 如果 Fiber 是通过将 blocking: false 传递给 Fiber.new 或通过 Fiber.schedule 创建的，则它是非阻塞的。
如果当前的 Fiber 是阻塞的，则该方法返回 1。 未来的开发可能会允许返回更大的整数的情况。
请注意，即使该方法返回 false，仅当 Fiber.scheduler 在当前线程中设置时，Fiber 的行为才会有所不同。
有关详细信息，请参阅类文档中的“非阻塞 fiber”部分。
来源
static VALUE
rb_fiber_s_current(VALUE klass)
{
return rb_fiber_current();
}
返回当前的 fiber。 如果您不是在 fiber 的上下文中运行，则此方法将返回根 fiber。
来源
static VALUE
rb_fiber_current_scheduler(VALUE klass)
{
return rb_fiber_scheduler_current();
}
返回 Fiber 调度器，该调度器是最后一次使用 Fiber.set_scheduler 为当前线程设置的，当且仅当当前 fiber 是非阻塞的。
来源
static VALUE
rb_fiber_initialize(int argc, VALUE* argv, VALUE self)
{
return rb_fiber_initialize_kw(argc, argv, self, rb_keyword_given_p());
}
创建新的 Fiber。 最初，fiber 没有运行，可以使用 resume 恢复。 第一次 resume 调用的参数将传递给块
f = Fiber.new do |initial| current = initial loop do puts "current: #{current.inspect}" current = Fiber.yield end end f.resume(100) # prints: current: 100 f.resume(1, 2, 3) # prints: current: [1, 2, 3] f.resume # prints: current: nil # ... and so on ...
如果将 blocking: false 传递给 Fiber.new，并且当前线程定义了 Fiber.scheduler，则 Fiber 将变为非阻塞的（请参阅类文档中的“非阻塞 Fiber”部分）。
如果未指定 storage，则默认是从当前 fiber 继承存储的副本。 这与指定 storage: true 相同。
Fiber[:x] = 1 Fiber.new do Fiber[:x] # => 1 Fiber[:x] = 2 end.resume Fiber[:x] # => 1
如果给定的 storage 为 nil，此函数将延迟初始化内部存储，该存储初始为空哈希。
Fiber[:x] = "Hello World" Fiber.new(storage: nil) do Fiber[:x] # nil end
否则，给定的 storage 将用作新 fiber 的存储，并且它必须是 Hash 的实例。
显式使用 storage: true 目前是实验性的，将来可能会更改。
来源
static VALUE
rb_fiber_s_schedule(int argc, VALUE *argv, VALUE obj)
{
return rb_fiber_s_schedule_kw(argc, argv, rb_keyword_given_p());
}
该方法应该立即在单独的非阻塞 fiber 中运行提供的代码块。
puts "Go to sleep!" Fiber.set_scheduler(MyScheduler.new) Fiber.schedule do puts "Going to sleep" sleep(1) puts "I slept well" end puts "Wakey-wakey, sleepyhead"
假设 MyScheduler 已正确实现，此程序将产生
Go to sleep! Going to sleep Wakey-wakey, sleepyhead ...1 sec pause here... I slept well
...例如，在 Fiber 内的第一个阻塞操作 (sleep(1)) 时，控制权将交给外部代码（主 fiber），并且在该执行结束时，调度器负责正确恢复所有阻塞的 fiber。
请注意，上述行为是该方法应该如何表现，实际行为取决于当前调度器的 Fiber::Scheduler#fiber 方法的实现。 Ruby 不强制此方法以任何特定方式表现。
如果未设置调度器，则该方法会引发 RuntimeError (没有可用的调度器！)。
来源
static VALUE
rb_fiber_s_scheduler(VALUE klass)
{
return rb_fiber_scheduler_get();
}
返回 Fiber 调度器，该调度器是最后一次使用 Fiber.set_scheduler 为当前线程设置的。 如果未设置调度器（这是默认值），则返回 nil，并且非阻塞 fiber 的行为与阻塞相同。（有关调度器概念的详细信息，请参阅类文档中的“非阻塞 fiber”部分）。
来源
static VALUE
rb_fiber_set_scheduler(VALUE klass, VALUE scheduler)
{
return rb_fiber_scheduler_set(scheduler);
}
为当前线程设置 Fiber 调度器。 如果设置了调度器，则非阻塞 fiber（通过 Fiber.new 与 blocking: false 或通过 Fiber.schedule 创建）在可能阻塞的操作上调用该调度器的挂钩方法，并且当前线程将在最终确定时调用调度器的 close 方法（允许调度器正确管理所有未完成的 fiber）。
scheduler 可以是任何对应于 Fiber::Scheduler 的类的对象。 其实现由用户决定。
另请参阅类文档中的“非阻塞 fiber”部分。
来源
static VALUE
rb_fiber_s_yield(int argc, VALUE *argv, VALUE klass)
{
return rb_fiber_yield_kw(argc, argv, rb_keyword_given_p());
}
将控制权返回给恢复 fiber 的上下文，并将传递给它的任何参数传递过去。 当下次调用 resume 时，fiber 将在此处恢复处理。 传递给下一个 resume 的任何参数都将是此 Fiber.yield 表达式的计算值。
公共实例方法
来源
VALUE
rb_fiber_alive_p(VALUE fiber_value)
{
return RBOOL(!FIBER_TERMINATED_P(fiber_ptr(fiber_value)));
}
如果 fiber 仍然可以恢复（或转移到），则返回 true。 在 fiber 块执行完毕后，此方法将始终返回 false。
来源
static VALUE
rb_fiber_backtrace(int argc, VALUE *argv, VALUE fiber)
{
return rb_vm_backtrace(argc, argv, &fiber_ptr(fiber)->cont.saved_ec);
}
返回 fiber 的当前执行堆栈。 start、count 和 end 允许仅选择回溯的部分。
def level3 Fiber.yield end def level2 level3 end def level1 level2 end f = Fiber.new { level1 } # It is empty before the fiber started f.backtrace #=> [] f.resume f.backtrace #=> ["test.rb:2:in `yield'", "test.rb:2:in `level3'", "test.rb:6:in `level2'", "test.rb:10:in `level1'", "test.rb:13:in `block in <main>'"] p f.backtrace(1) # start from the item 1 #=> ["test.rb:2:in `level3'", "test.rb:6:in `level2'", "test.rb:10:in `level1'", "test.rb:13:in `block in <main>'"] p f.backtrace(2, 2) # start from item 2, take 2 #=> ["test.rb:6:in `level2'", "test.rb:10:in `level1'"] p f.backtrace(1..3) # take items from 1 to 3 #=> ["test.rb:2:in `level3'", "test.rb:6:in `level2'", "test.rb:10:in `level1'"] f.resume # It is nil after the fiber is finished f.backtrace #=> nil
来源
static VALUE
rb_fiber_backtrace_locations(int argc, VALUE *argv, VALUE fiber)
{
return rb_vm_backtrace_locations(argc, argv, &fiber_ptr(fiber)->cont.saved_ec);
}
与 backtrace 类似，但将执行堆栈的每一行作为 Thread::Backtrace::Location 返回。 接受与 backtrace 相同的参数。
f = Fiber.new { Fiber.yield } f.resume loc = f.backtrace_locations.first loc.label #=> "yield" loc.path #=> "test.rb" loc.lineno #=> 1
来源
VALUE
rb_fiber_blocking_p(VALUE fiber)
{
return RBOOL(fiber_ptr(fiber)->blocking);
}
如果 fiber 是阻塞的，则返回 true，否则返回 false。 如果 Fiber 是通过将 blocking: false 传递给 Fiber.new 或通过 Fiber.schedule 创建的，则它是非阻塞的。
请注意，即使该方法返回 false，仅当 Fiber.scheduler 在当前线程中设置时，fiber 的行为才会有所不同。
有关详细信息，请参阅类文档中的“非阻塞 fiber”部分。
来源
static VALUE
rb_fiber_m_kill(VALUE self)
{
rb_fiber_t *fiber = fiber_ptr(self);
if (fiber->killed) return Qfalse;
fiber->killed = 1;
if (fiber->status == FIBER_CREATED) {
fiber->status = FIBER_TERMINATED;
}
else if (fiber->status != FIBER_TERMINATED) {
if (fiber_current() == fiber) {
fiber_check_killed(fiber);
}
else {
fiber_raise(fiber_ptr(self), Qnil);
}
}
return self;
}
通过抛出一个无法捕获的异常来终止纤程。它只会终止给定的纤程，而不会终止其他纤程。如果其他纤程正在调用 resume 或 transfer，则返回 nil 给该纤程。
只有当纤程处于 Fiber.yield 状态时，Fiber#kill 才会中断另一个纤程。如果对当前纤程调用此方法，则会在 Fiber#kill 调用处引发该异常。
如果纤程尚未启动，则直接转换为终止状态。
如果纤程已终止，则不执行任何操作。
如果在属于另一个线程的纤程上调用，则引发 FiberError。
来源
static VALUE
rb_fiber_m_raise(int argc, VALUE *argv, VALUE self)
{
return rb_fiber_raise(self, argc, argv);
}
在上次调用 Fiber.yield 的位置，在纤程中引发异常。如果纤程尚未启动或已运行完毕，则引发 FiberError。如果纤程正在让步 (yielding)，则会恢复执行。如果正在转移 (transferring)，则会转移到该纤程中。但是，如果正在恢复 (resuming)，则会引发 FiberError。
如果没有参数，则引发 RuntimeError。如果只有一个 String 参数，则会引发一个 RuntimeError，并将该字符串作为消息。否则，第一个参数应该是 Exception 类的名称（或在发送 exception 消息时返回 Exception 对象的对象）。可选的第二个参数设置与异常关联的消息，第三个参数是回调信息数组。异常由 begin...end 块的 rescue 子句捕获。
如果在属于另一个 Thread 的 Fiber 上调用，则引发 FiberError。
有关更多信息，请参阅 Kernel#raise。
来源
static VALUE
rb_fiber_m_resume(int argc, VALUE *argv, VALUE fiber)
{
return rb_fiber_resume_kw(fiber, argc, argv, rb_keyword_given_p());
}
从上次调用 Fiber.yield 的位置恢复纤程，或者如果这是第一次调用 resume，则开始运行它。传递给 resume 的参数将是 Fiber.yield 表达式的值，或者如果这是第一次 resume，则作为块参数传递给纤程的块。
或者，当调用 resume 时，它会计算为传递给纤程块内下一个 Fiber.yield 语句的参数，或者如果没有 Fiber.yield 而运行到完成时的块值。
来源
static VALUE
rb_fiber_storage_get(VALUE self)
{
storage_access_must_be_from_same_fiber(self);
VALUE storage = fiber_storage_get(fiber_ptr(self), FALSE);
if (storage == Qnil) {
return Qnil;
}
else {
return rb_obj_dup(storage);
}
}
返回纤程的存储哈希的副本。此方法只能在 Fiber.current 上调用。
来源
static VALUE
rb_fiber_storage_set(VALUE self, VALUE value)
{
if (rb_warning_category_enabled_p(RB_WARN_CATEGORY_EXPERIMENTAL)) {
rb_category_warn(RB_WARN_CATEGORY_EXPERIMENTAL,
"Fiber#storage= is experimental and may be removed in the future!");
}
storage_access_must_be_from_same_fiber(self);
fiber_storage_validate(value);
fiber_ptr(self)->cont.saved_ec.storage = rb_obj_dup(value);
return value;
}
设置纤程的存储哈希。此功能是实验性的，将来可能会更改。此方法只能在 Fiber.current 上调用。
你应该小心使用此方法，因为你可能会无意中清除重要的纤程存储状态。你应该主要倾向于使用 Fiber::[]= 在存储中分配特定的键。
你也可以使用 Fiber.new(storage: nil) 创建一个带有空存储的纤程。
示例
while request = request_queue.pop # Reset the per-request state: Fiber.current.storage = nil handle_request(request) end
来源
static VALUE
fiber_to_s(VALUE fiber_value)
{
const rb_fiber_t *fiber = fiber_ptr(fiber_value);
const rb_proc_t *proc;
char status_info[0x20];
if (fiber->resuming_fiber) {
snprintf(status_info, 0x20, " (%s by resuming)", fiber_status_name(fiber->status));
}
else {
snprintf(status_info, 0x20, " (%s)", fiber_status_name(fiber->status));
}
if (!rb_obj_is_proc(fiber->first_proc)) {
VALUE str = rb_any_to_s(fiber_value);
strlcat(status_info, ">", sizeof(status_info));
rb_str_set_len(str, RSTRING_LEN(str)-1);
rb_str_cat_cstr(str, status_info);
return str;
}
GetProcPtr(fiber->first_proc, proc);
return rb_block_to_s(fiber_value, &proc->block, status_info);
}
来源
static VALUE
rb_fiber_m_transfer(int argc, VALUE *argv, VALUE self)
{
return rb_fiber_transfer_kw(self, argc, argv, rb_keyword_given_p());
}
将控制权转移到另一个纤程，从上次停止的位置恢复它，或者如果之前未恢复则开始运行它。调用纤程将像调用 Fiber.yield 一样被挂起。
接收 transfer 调用的纤程将其视为类似 resume 的调用。传递给 transfer 的参数被视为类似于传递给 resume 的参数。
在纤程之间传递控制权的两种样式（一种是 resume 和 Fiber::yield，另一种是 transfer 在纤程之间）不能自由混合。
-
如果纤程的生命周期以 transfer 开始，它将永远无法让步或恢复控制权传递，只能完成或转移回去。（它仍然可以恢复允许恢复的其他纤程。）
-
如果纤程的生命周期以 resume 开始，它可以让步或转移到另一个
Fiber，但只能以与它被放弃的方式兼容的方式接收控制权：如果它已转移，则只能转移回去，如果它已让步，则只能恢复回来。之后，它可以再次转移或让步。
如果违反了这些规则，则会引发 FiberError。
对于单个 Fiber 设计，让步/恢复更容易使用（Fiber 只是放弃控制权，它不需要考虑控制权被给予谁），而 transfer 对于复杂的情况更灵活，允许构建相互依赖的纤程的任意图。
示例
manager = nil # For local var to be visible inside worker block # This fiber would be started with transfer # It can't yield, and can't be resumed worker = Fiber.new { |work| puts "Worker: starts" puts "Worker: Performed #{work.inspect}, transferring back" # Fiber.yield # this would raise FiberError: attempt to yield on a not resumed fiber # manager.resume # this would raise FiberError: attempt to resume a resumed fiber (double resume) manager.transfer(work.capitalize) } # This fiber would be started with resume # It can yield or transfer, and can be transferred # back or resumed manager = Fiber.new { puts "Manager: starts" puts "Manager: transferring 'something' to worker" result = worker.transfer('something') puts "Manager: worker returned #{result.inspect}" # worker.resume # this would raise FiberError: attempt to resume a transferring fiber Fiber.yield # this is OK, the fiber transferred from and to, now it can yield puts "Manager: finished" } puts "Starting the manager" manager.resume puts "Resuming the manager" # manager.transfer # this would raise FiberError: attempt to transfer to a yielding fiber manager.resume
产生
Starting the manager Manager: starts Manager: transferring 'something' to worker Worker: starts Worker: Performed "something", transferring back Manager: worker returned "Something" Resuming the manager Manager: finished