class Channel(T)
Overview
A Channel
enables concurrent communication between fibers.
They allow communicating data between fibers without sharing memory and without having to worry about locks, semaphores or other special structures.
channel = Channel(Int32).new
spawn do
channel.send(0)
channel.send(1)
end
channel.receive # => 0
channel.receive # => 1
NOTE Although a Channel(Nil)
or any other nilable types like Channel(Int32?)
are valid
they are discouraged since from certain methods or constructs it receiving a nil
as data
will be indistinguishable from a closed channel.
Defined in:
channel.crchannel/select.cr
channel/select/select_action.cr
channel/select/timeout_action.cr
Constructors
Class Method Summary
- .receive_first(channels : Enumerable(Channel))
- .receive_first(*channels)
- .send_first(value, channels : Enumerable(Channel)) : Nil
- .send_first(value, *channels) : Nil
Instance Method Summary
-
#close : Bool
Closes the channel.
- #closed? : Bool
-
#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.
- #pretty_print(pp)
-
#receive : T
Receives a value from the channel.
-
#receive? : T | Nil
Receives a value from the channel.
-
#send(value : T) : self
Sends a value to the channel.
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
Class Method Detail
Instance Method Detail
Closes the channel. The method prevents any new value from being sent to the channel.
If the channel has buffered values, then subsequent calls to #receive
will succeed
and consume the buffer until it is empty.
All fibers blocked in #send
or #receive
will be awakened with Channel::ClosedError
.
All subsequent calls to #send
will consider the channel closed.
Subsequent calls to #receive
will consider the channel closed if the buffer is empty.
Calling #close
on a closed channel does not have any effect.
It returns true
when the channel was successfully closed, or false
if it was already closed.
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>
Receives a value from the channel. If there is a value waiting, then it is returned immediately. Otherwise, this method blocks until a value is sent to the channel.
Raises ClosedError
if the channel is closed or closes while waiting for receive.
channel = Channel(Int32).new
spawn do
channel.send(1)
end
channel.receive # => 1
Receives a value from the channel. If there is a value waiting, it is returned immediately. Otherwise, this method blocks until a value is sent to the channel.
Returns nil
if the channel is closed or closes while waiting for receive.
Sends a value to the channel.
If the channel has spare capacity, then the method returns immediately.
Otherwise, this method blocks the calling fiber until another fiber calls #receive
on the channel.
Raises ClosedError
if the channel is closed or closes while waiting on a full channel.