class
   Fiber::ExecutionContext::Isolated
  
  
  Overview
Isolated execution context to run a single fiber.
Concurrency and parallelism are disabled. The context guarantees that the fiber will always run on the same system thread until it terminates; the fiber owns the system thread for its whole lifetime.
Keep in mind that the fiber will still run in parallel to other fibers running in other execution contexts at the same time.
Concurrency is disabled, so an isolated fiber can't spawn fibers into the
context, but it can spawn fibers into other execution contexts. Since it can
be inconvenient to pass an execution context around, calls to ::spawn will
spawn a fiber into the specified spawn_context during initialization,
which defaults to Fiber::ExecutionContext.default.
Isolated fibers can normally communicate with other fibers running in other
execution contexts using Channel, WaitGroup or Mutex for example. They
can also execute IO operations or sleep just like any other fiber.
Calls that result in waiting (e.g. sleep, or socket read/write) will block the thread since there are no other fibers to switch to. This in turn allows to call anything that would block the thread without blocking any other fiber.
For example you can start an isolated fiber to run a blocking GUI loop,
transparently forward ::spawn to the default context, then keep the main
fiber to wait until the GUI application quit:
gtk = Fiber::ExecutionContext::Isolated.new("Gtk") do
  Gtk.main
end
gtk.waitIncluded Modules
- Fiber::ExecutionContext
- Fiber::ExecutionContext::Scheduler
Defined in:
fiber/execution_context/isolated.crConstructors
- 
        .new(name : String, spawn_context : ExecutionContext = ExecutionContext.default, &func :  -> )
        
          Starts a new thread named name to execute func. 
Instance Method Summary
- 
        #inspect(io : IO) : Nil
        
          Appends a String representation of this object which includes its class name, its object address and the values of all instance variables. 
- #name : String
- #running? : Bool
- 
        #spawn(*, name : String | Nil = nil, &block :  -> ) : Fiber
        
          Instantiates a fiber and enqueues it into the scheduler's local queue. 
- 
        #status : String
        
          Returns the current status of the scheduler. 
- 
        #to_s(io : IO) : Nil
        
          Appends a short String representation of this object which includes its class name and its object address. 
- 
        #wait : Nil
        
          Blocks the calling fiber until the isolated context fiber terminates. 
Instance methods inherited from module Fiber::ExecutionContext::Scheduler
  
  
    
      spawn(*, name : String | Nil = nil, &block :  -> ) : Fiberspawn(*, name : String | Nil = nil, same_thread : Bool, &) : Fiber spawn, status : String status
Constructor methods inherited from module Fiber::ExecutionContext::Scheduler
  
  
    
      current : Scheduler
    current
    
  
      
      
    
      
  Instance methods inherited from module Fiber::ExecutionContext
  
  
    
      spawn(*, name : String | Nil = nil, &block :  -> ) : Fiber
    spawn
    
  
      
  Constructor methods inherited from module Fiber::ExecutionContext
  
  
    
      current : ExecutionContext
    current, 
    
  
    
      default : ExecutionContext
    default
    
  
      
  Class methods inherited from module Fiber::ExecutionContext
  
  
    
      current? : ExecutionContext | Nil
    current?, 
    
  
    
      default_workers_count : Int32
    default_workers_count, 
    
  
    
      each(&) : Nil
    each
    
  
      
    
      
  Instance methods inherited from class Reference
  
  
    
      ==(other : self)==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup, hash(hasher) hash, initialize initialize, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, same?(other : Reference) : Bool
same?(other : Nil) same?, to_s(io : IO) : Nil to_s
Constructor methods inherited from class Reference
  
  
    
      new
    new, 
    
  
    
      unsafe_construct(address : Pointer, *args, **opts) : self
    unsafe_construct
    
  
      
  Class methods inherited from class Reference
  
  
    
      pre_initialize(address : Pointer)
    pre_initialize
    
  
      
    
      
  Instance methods inherited from class Object
  
  
    
      ! : Bool
    !, 
    
  
    
      !=(other)
    !=, 
    
  
    
      !~(other)
    !~, 
    
  
    
      ==(other)
    ==, 
    
  
    
      ===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as
Class methods inherited from class Object
  
  
    
      from_json(string_or_io, root : String)from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml
Macros inherited from class Object
  
  
    
      class_getter(*names, &block)
    class_getter, 
    
  
    
      class_getter!(*names)
    class_getter!, 
    
  
    
      class_getter?(*names, &block)
    class_getter?, 
    
  
    
      class_property(*names, &block)
    class_property, 
    
  
    
      class_property!(*names)
    class_property!, 
    
  
    
      class_property?(*names, &block)
    class_property?, 
    
  
    
      class_setter(*names)
    class_setter, 
    
  
    
      def_clone
    def_clone, 
    
  
    
      def_equals(*fields)
    def_equals, 
    
  
    
      def_equals_and_hash(*fields)
    def_equals_and_hash, 
    
  
    
      def_hash(*fields)
    def_hash, 
    
  
    
      delegate(*methods, to object)
    delegate, 
    
  
    
      forward_missing_to(delegate)
    forward_missing_to, 
    
  
    
      getter(*names, &block)
    getter, 
    
  
    
      getter!(*names)
    getter!, 
    
  
    
      getter?(*names, &block)
    getter?, 
    
  
    
      property(*names, &block)
    property, 
    
  
    
      property!(*names)
    property!, 
    
  
    
      property?(*names, &block)
    property?, 
    
  
    
      setter(*names)
    setter
    
  
    
  Constructor Detail
Starts a new thread named name to execute func. Once func returns the thread will terminate.
Instance Method Detail
Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.
class Person
  def initialize(@name : String, @age : Int32)
  end
end
Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>Instantiates a fiber and enqueues it into the scheduler's local queue.
Returns the current status of the scheduler. For example "running",
"event-loop" or "parked".
Appends a short String representation of this object which includes its class name and its object address.
class Person
  def initialize(@name : String, @age : Int32)
  end
end
Person.new("John", 32).to_s # => #<Person:0x10a199f20>Blocks the calling fiber until the isolated context fiber terminates. Returns immediately if the isolated fiber has already terminated. Re-raises unhandled exceptions raised by the fiber.
For example:
ctx = Fiber::ExecutionContext::Isolated.new("test") do
  raise "fail"
end
ctx.wait # => re-raises "fail"