class Concurrent::AbstractExchanger
@!visibility private
Constants
- CANCEL
@!visibility private
Public Class Methods
new()
click to toggle source
Calls superclass method
# File lib/concurrent-ruby/concurrent/exchanger.rb, line 44 def initialize super end
Public Instance Methods
exchange(value, timeout = nil)
click to toggle source
@!macro exchanger_method_do_exchange
Waits for another thread to arrive at this exchange point (unless the current thread is interrupted), and then transfers the given object to it, receiving its object in return. The timeout value indicates the approximate number of seconds the method should block while waiting for the exchange. When the timeout value is `nil` the method will block indefinitely. @param [Object] value the value to exchange with another thread @param [Numeric, nil] timeout in seconds, `nil` blocks indefinitely
@!macro exchanger_method_exchange
In some edge cases when a `timeout` is given a return value of `nil` may be ambiguous. Specifically, if `nil` is a valid value in the exchange it will be impossible to tell whether `nil` is the actual return value or if it signifies timeout. When `nil` is a valid value in the exchange consider using {#exchange!} or {#try_exchange} instead. @return [Object] the value exchanged by the other thread or `nil` on timeout
# File lib/concurrent-ruby/concurrent/exchanger.rb, line 69 def exchange(value, timeout = nil) (value = do_exchange(value, timeout)) == CANCEL ? nil : value end
exchange!(value, timeout = nil)
click to toggle source
@!macro exchanger_method_do_exchange @!macro exchanger_method_exchange_bang
On timeout a {Concurrent::TimeoutError} exception will be raised. @return [Object] the value exchanged by the other thread @raise [Concurrent::TimeoutError] on timeout
# File lib/concurrent-ruby/concurrent/exchanger.rb, line 80 def exchange!(value, timeout = nil) if (value = do_exchange(value, timeout)) == CANCEL raise Concurrent::TimeoutError else value end end
try_exchange(value, timeout = nil)
click to toggle source
@!macro exchanger_method_do_exchange @!macro exchanger_method_try_exchange
The return value will be a {Concurrent::Maybe} set to `Just` on success or `Nothing` on timeout. @return [Concurrent::Maybe] on success a `Just` maybe will be returned with the item exchanged by the other thread as `#value`; on timeout a `Nothing` maybe will be returned with {Concurrent::TimeoutError} as `#reason` @example exchanger = Concurrent::Exchanger.new result = exchanger.exchange(:foo, 0.5) if result.just? puts result.value #=> :bar else puts 'timeout' end
# File lib/concurrent-ruby/concurrent/exchanger.rb, line 109 def try_exchange(value, timeout = nil) if (value = do_exchange(value, timeout)) == CANCEL Concurrent::Maybe.nothing(Concurrent::TimeoutError) else Concurrent::Maybe.just(value) end end
Private Instance Methods
do_exchange(value, timeout)
click to toggle source
@!macro exchanger_method_do_exchange
@return [Object, CANCEL] the value exchanged by the other thread; {CANCEL} on timeout
# File lib/concurrent-ruby/concurrent/exchanger.rb, line 122 def do_exchange(value, timeout) raise NotImplementedError end