class Fiber::ExecutionContext::MultiThreaded

Overview

A multi-threaded execution context which owns one or more threads. It's fully concurrent and fully parallel.

Owns multiple threads and starts a scheduler in each one. The number of threads is dynamic. Setting the minimum and maximum to the same value will start a fixed number of threads.

Fibers running in this context can be resumed by any thread in the context. Fibers can run concurrently and in parallel to each other, in addition to running in parallel to any other fiber running in other contexts.

mt_context = Fiber::ExecutionContext::MultiThreaded.new("worker-threads", 4)

10.times do
  mt_context.spawn do
    do_something
  end
end

sleep

Included Modules

Defined in:

fiber/execution_context/multi_threaded.cr
fiber/execution_context/multi_threaded/scheduler.cr

Constructors

Instance Method Summary

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

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

def self.new(name : String, maximum : Int32) : self #

Starts a context with a maximum number of threads. Threads aren't started right away but will be started as needed to increase parallelism up to the configured maximum.


[View source]
def self.new(name : String, size : Range(Nil, Int32)) : self #

Starts a context with a maximum number of threads. Threads aren't started right away but will be started as needed to increase parallelism up to the configured maximum.


[View source]
def self.new(name : String, size : Range(Int32, Int32)) : self #

Starts a context with a minimum and maximum number of threads. Only the minimum number of threads will be started right away. The minimum can be 0 (or nil) in which case no threads will be started. More threads will be started as needed to increase parallelism up to the configured maximum.


[View source]

Instance Method Detail

def capacity : Int32 #

The maximum number of threads that can be started.


[View source]
def inspect(io : IO) : Nil #
Description copied from class Reference

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>

[View source]
def name : String #

[View source]
def size : Int32 #

The number of threads that have been started.


[View source]
def to_s(io : IO) : Nil #
Description copied from class Reference

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>

[View source]