Class: Concurrent::IVar

Inherits:
Object
  • Object
show all
Includes:
Obligation, Observable
Defined in:
lib/concurrent/ivar.rb

Overview

An ‘IVar` is a single-element container that is normally created empty, and can only be set once. The I in `IVar` stands for immutable. Reading an `IVar` normally blocks until it is set. It is safe to set and read an `IVar` from different threads.

If you want to have some parallel task set the value in an ‘IVar`, you want a `Future`. If you want to create a graph of parallel tasks all executed when the values they depend on are ready you want `dataflow`. `IVar` is generally a low-level primitive.

Examples:

Create, set and get an ‘IVar`

ivar = Concurrent::IVar.new
ivar.set 14
ivar.get #=> 14
ivar.set 2 # would now be an error

Direct Known Subclasses

Channel::Probe, Future, ScheduledTask

Instance Method Summary collapse

Methods included from Observable

#count_observers, #delete_observer, #delete_observers, #with_observer

Methods included from Obligation

#completed?, #exception, #fulfilled?, #incomplete?, #no_error!, #pending?, #reason, #rejected?, #state, #unscheduled?, #value, #value!, #wait

Methods included from Dereferenceable

#value

Constructor Details

#initialize(value = NO_VALUE, opts = {}) ⇒ IVar

Create a new ‘IVar` in the `:pending` state with the (optional) initial value.

Parameters:

  • value (Object) (defaults to: NO_VALUE) —

    the initial value

  • opts (Hash) (defaults to: {}) —

    the options to create a message with

Options Hash (opts):

  • :dup_on_deref (String) — default: false —

    call ‘#dup` before returning the data

  • :freeze_on_deref (String) — default: false —

    call ‘#freeze` before returning the data

  • :copy_on_deref (String) — default: nil —

    call the given ‘Proc` passing the internal value and returning the value returned from the proc



40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/concurrent/ivar.rb', line 40

def initialize(value = NO_VALUE, opts = {})
  init_obligation
  self.observers = CopyOnWriteObserverSet.new
  set_deref_options(opts)

  if value == NO_VALUE
    @state = :pending
  else
    set(value)
  end
end

Instance Method Details

#add_observer(observer = nil, func = :update, &block) ⇒ Object

Add an observer on this object that will receive notification on update.

Upon completion the ‘IVar` will notify all observers in a thread-say way. The `func` method of the observer will be called with three arguments: the `Time` at which the `Future` completed the asynchronous operation, the final `value` (or `nil` on rejection), and the final `reason` (or `nil` on fulfillment).

Parameters:

  • observer (Object) (defaults to: nil) —

    the object that will be notified of changes

  • func (Symbol) (defaults to: :update) —

    symbol naming the method to call when this ‘Observable` has changes`

Raises:

  • (ArgumentError) 


61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/concurrent/ivar.rb', line 61

def add_observer(observer = nil, func = :update, &block)
  raise ArgumentError.new('cannot provide both an observer and a block') if observer && block
  direct_notification = false

  if block
    observer = block
    func = :call
  end

  mutex.synchronize do
    if event.set?
      direct_notification = true
    else
      observers.add_observer(observer, func)
    end
  end

  observer.send(func, Time.now, self.value, reason) if direct_notification
  observer
end

#fail(reason = StandardError.new) ⇒ Object

Set the ‘IVar` to failed due to some error and wake or notify all threads waiting on it.

Parameters:

  • reason (Object) (defaults to: StandardError.new) —

    for the failure

Raises:



94
95
96
 
# File 'lib/concurrent/ivar.rb', line 94

def fail(reason = StandardError.new)
  complete(false, nil, reason)
end

#set(value) ⇒ Object

Set the ‘IVar` to a value and wake or notify all threads waiting on it.

Parameters:

  • value (Object) —

    the value to store in the ‘IVar`

Raises:



86
87
88
 
# File 'lib/concurrent/ivar.rb', line 86

def set(value)
  complete(true, value, nil)
end