Class: Celluloid::Future

Inherits:
Object
  • Object
show all
Defined in:
lib/celluloid/future.rb

Overview

Celluloid::Future objects allow methods and blocks to run in the background, their values requested later

Defined Under Namespace

Classes: Result

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(&block) ⇒ Future

Returns a new instance of Future.



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/celluloid/future.rb', line 26

def initialize(&block)
  @address = Celluloid.uuid
  @mutex = Mutex.new
  @ready = false
  @result = nil
  @forwards = nil
  @cancelled = false

  if block
    @call = Call::Sync.new(self, :call, args)
    Celluloid.internal_pool.get do
      begin
        @call.dispatch(block)
      rescue
        # Exceptions in blocks will get raised when the value is retrieved
      end
    end
  else
    @call = nil
  end
end

Instance Attribute Details

#address ⇒ Object (readonly)

Returns the value of attribute address.



24
25
26
 
# File 'lib/celluloid/future.rb', line 24

def address
  @address
end

Class Method Details

.new(*args, &block) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/celluloid/future.rb', line 5

def self.new(*args, &block)
  return super unless block

  future = new
  # task = Thread.current[:celluloid_task]
  # actor = Thread.current[:celluloid_actor]
  Internals::ThreadHandle.new(Celluloid.actor_system, :future) do
    begin
      # Thread.current[:celluloid_task] = task
      # Thread.current[:celluloid_actor] = actor
      call = Call::Sync.new(future, :call, args)
      call.dispatch(block)
    rescue
      # Exceptions in blocks will get raised when the value is retrieved
    end
  end
  future
end

Instance Method Details

#cancel(error) ⇒ Object 



119
120
121
122
123
124
125
 
# File 'lib/celluloid/future.rb', line 119

def cancel(error)
  response = Internals::Response::Error.new(@call, error)
  signal response
  @mutex.synchronize do
    @cancelled = true
  end
end

#execute(receiver, method, args, block) ⇒ Object

Execute the given method in future context



49
50
51
52
53
54
55
56
 
# File 'lib/celluloid/future.rb', line 49

def execute(receiver, method, args, block)
  @mutex.synchronize do
    raise "already calling" if @call
    @call = Call::Sync.new(self, method, args, block)
  end

  receiver << @call
end

#ready? ⇒ Boolean

Check if this future has a value yet

Returns:

  • (Boolean) 


59
60
61
 
# File 'lib/celluloid/future.rb', line 59

def ready?
  @ready
end

#signal(value) ⇒ Object Also known as: <<

Signal this future with the given result value



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/celluloid/future.rb', line 102

def signal(value)
  return if @cancelled
  result = Result.new(value, self)

  @mutex.synchronize do
    raise "the future has already happened!" if @ready

    if @forwards
      @forwards.is_a?(Array) ? @forwards.each { |f| f << result } : @forwards << result
    end

    @result = result
    @ready = true
  end
end

#value(timeout = nil) ⇒ Object Also known as: call

Obtain the value for this Future



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/celluloid/future.rb', line 64

def value(timeout = nil)
  ready = result = nil

  begin
    @mutex.lock

    if @ready
      ready = true
      result = @result
    else
      case @forwards
      when Array
        @forwards << Celluloid.mailbox
      when NilClass
        @forwards = Celluloid.mailbox
      else
        @forwards = [@forwards, Celluloid.mailbox]
      end
    end
  ensure
    @mutex.unlock
  end

  unless ready
    result = Celluloid.receive(timeout) do |msg|
      msg.is_a?(Future::Result) && msg.future == self
    end
  end

  if result
    result.respond_to?(:value) ? result.value : result
  else
    raise TimedOut, "Timed out"
  end
end