concurrent-ruby 0.1.1.pre.5 → 0.1.1

data/lib/concurrent/global_thread_pool.rb

@@ -1,16 +1,3 @@
 require 'concurrent/cached_thread_pool'
 
 $GLOBAL_THREAD_POOL ||= Concurrent::CachedThreadPool.new
-
-module Concurrent
-
-  module UsesGlobalThreadPool
-
-    def self.included(base)
-      class << base
-        attr_accessor :thread_pool
-      end
-      base.thread_pool = $GLOBAL_THREAD_POOL
-    end
-  end
-end

data/lib/concurrent/goroutine.rb

@@ -19,11 +19,7 @@ module Kernel
   # @see https://gobyexample.com/goroutines
   def go(*args, &block)
     return false unless block_given?
-    if args.first.behaves_as?(:global_thread_pool)
-      args.first.post(*args.slice(1, args.length), &block)
-    else
-      $GLOBAL_THREAD_POOL.post(*args, &block)
-    end
+    $GLOBAL_THREAD_POOL.post(*args, &block)
   end
   module_function :go
 end

data/lib/concurrent/obligation.rb

@@ -33,23 +33,19 @@ module Concurrent
     def fulfilled?() return(@state == :fulfilled); end
     alias_method :realized?, :fulfilled?
 
-    # Has the promise been rejected?
-    # @return [Boolean]
-    def rejected?() return(@state == :rejected); end
-
     # Is obligation completion still pending?
     # @return [Boolean]
-    def pending?() return(@state == :pending); end
+    def pending?() return(!(fulfilled? || rejected?)); end
 
     def value(timeout = nil)
-      if timeout == 0 || ! pending?
+      if !pending? || timeout == 0
         return @value
       elsif timeout.nil?
-        return mutex.synchronize { v = @value }
+        return semaphore.synchronize { @value }
       else
         begin
           return Timeout::timeout(timeout.to_f) {
-            mutex.synchronize { v = @value }
+            semaphore.synchronize { @value }
           }
         rescue Timeout::Error => ex
           return nil
@@ -58,10 +54,68 @@ module Concurrent
     end
     alias_method :deref, :value
 
+    # Has the promise been rejected?
+    # @return [Boolean]
+    def rejected?() return(@state == :rejected); end
+
     protected
 
-    def mutex
-      @mutex ||= Mutex.new
+    def semaphore
+      @semaphore ||= Mutex.new
+    end
+  end
+end
+
+module Kernel
+
+  def deref(obligation, timeout = nil)
+    if obligation.respond_to?(:deref)
+      return obligation.deref(timeout)
+    elsif obligation.respond_to?(:value)
+      return obligation.deref(timeout)
+    else
+      return nil
+    end
+  end
+  module_function :deref
+
+  def pending?(obligation)
+    if obligation.respond_to?(:pending?)
+      return obligation.pending?
+    else
+      return false
+    end
+  end
+  module_function :pending?
+
+  def fulfilled?(obligation)
+    if obligation.respond_to?(:fulfilled?)
+      return obligation.fulfilled?
+    elsif obligation.respond_to?(:realized?)
+      return obligation.realized?
+    else
+      return false
+    end
+  end
+  module_function :fulfilled?
+
+  def realized?(obligation)
+    if obligation.respond_to?(:realized?)
+      return obligation.realized?
+    elsif obligation.respond_to?(:fulfilled?)
+      return obligation.fulfilled?
+    else
+      return false
+    end
+  end
+  module_function :realized?
+
+  def rejected?(obligation)
+    if obligation.respond_to?(:rejected?)
+      return obligation.rejected?
+    else
+      return false
     end
   end
+  module_function :rejected?
 end

data/lib/concurrent/promise.rb

@@ -1,6 +1,5 @@
 require 'thread'
 
-require 'concurrent/global_thread_pool'
 require 'concurrent/obligation'
 require 'concurrent/utilities'
 
@@ -8,8 +7,6 @@ module Concurrent
 
   class Promise
     include Obligation
-    include UsesGlobalThreadPool
-
     behavior(:future)
     behavior(:promise)
 
@@ -36,22 +33,17 @@ module Concurrent
         @chain = [self]
       end
 
-      @lock = Mutex.new
+      @mutex = Mutex.new
       @handler = block || Proc.new{|result| result }
       @state = :pending
       @value = nil
       @reason = nil
-      @rescued = false
       @children = []
       @rescuers = []
 
       realize(*args) if root?
     end
 
-    def rescued?
-      return @rescued
-    end
-
     # Create a new child Promise. The block argument for the child will
     # be the result of fulfilling its parent. If the child will
     # immediately be rejected if the parent has already been rejected.
@@ -60,7 +52,7 @@ module Concurrent
     #
     # @return [Promise] the new promise
     def then(&block)
-      child = @lock.synchronize do
+      child = @mutex.synchronize do
         block = Proc.new{|result| result } unless block_given?
         @children << Promise.new(self, &block)
         @children.last.on_reject(@reason) if rejected?
@@ -81,14 +73,8 @@ module Concurrent
     #
     # @return [self] so that additional chaining can occur
     def rescue(clazz = Exception, &block)
-      return self if fulfilled? || rescued? || ! block_given?
-      @lock.synchronize do
-        rescuer = Rescuer.new(clazz, block)
-        if pending?
-          @rescuers << rescuer
-        else
-          try_rescue(reason, rescuer)
-        end
+      @mutex.synchronize do
+        @rescuers << Rescuer.new(clazz, block) if block_given?
       end
       return self
     end
@@ -104,6 +90,15 @@ module Concurrent
     # @private
     Rescuer = Struct.new(:clazz, :block)
 
+    # @private
+    def root # :nodoc:
+      return atomic {
+        current = self
+        current = current.parent until current.root?
+        current
+      }
+    end
+
     # @private
     def root? # :nodoc:
       @parent.nil?
@@ -120,44 +115,47 @@ module Concurrent
 
     # @private
     def on_fulfill(value) # :nodoc:
-      @lock.synchronize do
-        @value = @handler.call(value)
-        @state = :fulfilled
-        @reason = nil
+      @mutex.synchronize do
+        if pending?
+          @value = @handler.call(value)
+          @state = :fulfilled
+          @reason = nil
+        end
       end
       return @value
     end
 
     # @private
     def on_reject(reason) # :nodoc:
-      @value = nil
-      @state = :rejected
-      @reason = reason
-      try_rescue(reason)
-      @children.each{|child| child.on_reject(reason) }
+      @mutex.synchronize do
+        if pending?
+          @state = :rejected
+          @reason = reason
+          self.try_rescue(reason)
+          @value = nil
+        end
+        @children.each{|child| child.on_reject(reason) }
+      end
     end
 
     # @private
-    def try_rescue(ex, *rescuers) # :nodoc:
-      rescuers = @rescuers if rescuers.empty?
-      rescuer = rescuers.find{|r| ex.is_a?(r.clazz) }
-      if rescuer
-        rescuer.block.call(ex)
-        @rescued = true
-      end
+    def try_rescue(ex) # :nodoc:
+      rescuer = @rescuers.find{|r| ex.is_a?(r.clazz) }
+      rescuer.block.call(ex) if rescuer
     rescue Exception => e
       # supress
     end
 
     # @private
     def realize(*args) # :nodoc:
-      Promise.thread_pool.post(@chain, @lock, args) do |chain, lock, args|
+      Thread.new(@chain, @mutex, args) do |chain, mutex, args|
         result = args.length == 1 ? args.first : args
         index = 0
         loop do
-          current = lock.synchronize{ chain[index] }
+          Thread.pass
+          current = mutex.synchronize{ chain[index] }
           unless current.rejected?
-            current.mutex.synchronize do
+            current.semaphore.synchronize do
               begin
                 result = current.on_fulfill(result)
               rescue Exception => ex
@@ -166,9 +164,33 @@ module Concurrent
             end
           end
           index += 1
-          Thread.pass while index >= chain.length
+          sleep while index >= chain.length
         end
       end
     end
   end
 end
+
+module Kernel
+
+  # Creates a new promise object. "A promise represents the eventual
+  # value returned from the single completion of an operation."
+  # Promises can be chained in a tree structure where each promise
+  # has zero or more children. Promises are resolved asynchronously
+  # in the order they are added to the tree. Parents are guaranteed
+  # to be resolved before their children. The result of each promise
+  # is passes to each of its children when the child resolves. When
+  # a promise is rejected all its children will be summarily rejected.
+  # A promise added to a rejected promise will immediately be rejected.
+  # A promise that is neither resolved or rejected is pending.
+  #
+  # @param args [Array] zero or more arguments for the block
+  # @param block [Proc] the block to call when attempting fulfillment
+  #
+  # @see Promise
+  # @see http://wiki.commonjs.org/wiki/Promises/A
+  def promise(*args, &block)
+    return Concurrent::Promise.new(*args, &block)
+  end
+  module_function :promise
+end

data/lib/concurrent/thread_pool.rb

@@ -35,7 +35,7 @@ module Concurrent
     end
 
     def shutdown?
-      return @status == :shutdown
+      return ! running?
     end
 
     def killed?
@@ -43,14 +43,10 @@ module Concurrent
     end
 
     def shutdown
-      mutex.synchronize do
-        if @pool.empty?
-          @status = :shutdown
-        else
-          @status = :shuttingdown
-          @pool.size.times{ @queue << :stop }
-        end
-      end
+      atomic {
+        @pool.size.times{ @queue << :stop }
+        @status = :shuttingdown
+      }
     end
 
     def wait_for_termination(timeout = nil)
@@ -65,12 +61,5 @@ module Concurrent
       self.post(&block)
       return self
     end
-
-    protected
-
-    # @private
-    def mutex # :nodoc:
-      @mutex || Mutex.new
-    end
   end
 end

data/lib/concurrent/utilities.rb

@@ -20,13 +20,5 @@ module Kernel
     }.resume
   end
   module_function :atomic
-end
-
-class Mutex
 
-  def sync_with_timeout(timeout, &block)
-    Timeout::timeout(timeout) {
-      synchronize(&block)
-    }
-  end
 end

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.1.1.pre.5'
+  VERSION = '0.1.1'
 end

data/md/defer.md

@@ -2,14 +2,14 @@
 
 In the pantheon of concurrency objects a `Defer` sits somewhere between `Future` and `Promise`.
 Inspired by [EventMachine's *defer* method](https://github.com/eventmachine/eventmachine/wiki/EM::Deferrable-and-EM.defer),
-a `Defer` can be considered a non-blocking `Future` or a simplified, non-blocking `Promise`. Defers run on the global thread pool.
+a `Defer` can be considered a non-blocking `Future` or a simplified, non-blocking `Promise`.
 
 Unlike `Future` and `Promise` a defer is non-blocking. The deferred *operation* is performed on another
 thread. If the *operation* is successful an optional *callback* is called on the same thread as the *operation*.
 The result of the *operation* is passed to the *callbacl*. If the *operation* fails (by raising an exception)
-then an optional *errorback* (error callback) is called on the same thread as the *operation*. The raised
-exception is passed to the *errorback*. The calling thread is never aware of the result of the *operation*.
-This approach fits much more cleanly within an
+then an optional *errorback* (error callback) is called on
+the same thread as the *operation*. The raised exception is passed to the *errorback*. The calling thread is
+never aware of the result of the *operation*. This approach fits much more cleanly within an
 [event-driven](http://en.wikipedia.org/wiki/Event-driven_programming) application.
 
 The operation of a `Defer` can easily be simulated using either `Future` or `Promise` and traditional branching

data/md/promise.md

@@ -28,8 +28,6 @@ A *timeout* value can be passed to `value` to limit how long the call will block
 block indefinitely. If `0` the call will not block. Any other integer or float value will indicate the
 maximum number of seconds to block.
 
-Promises run on the global thread pool.
-
 ## Examples
 
 Start by requiring promises

data/md/thread_pool.md

@@ -151,12 +151,6 @@ $GLOBAL_THREAD_POOL = Concurrent::FixedThreadPool.new(10)
 old_global_pool.shutdown
 ```
 
-### NullThreadPool
-
-If for some reason an appliction would be better served by *not* having a global thread pool, the
-`NullThreadPool` is provided. The `NullThreadPool` is compatible with the global thread pool but
-it is not an actual thread pool. Instead it spawns a new thread on every call to the `post` method.
-
 ### EventMachine
 
 The [EventMachine](http://rubyeventmachine.com/) library (source [online](https://github.com/eventmachine/eventmachine))
@@ -173,27 +167,6 @@ require 'functional/concurrency'
 $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 ```
 
-## Per-class Thread Pools
-
-Many of the classes in this library use the global thread pool rather than creating new threads.
-Classes such as `Agent`, `Defer`, and others follow this pattern. There may be cases where a
-program would be better suited for one or more of these classes used a different thread pool.
-All classes that use the global thread pool support a class-level `thread_pool` attribute accessor.
-This property defaults to the global thread pool but can be changed at any time. Once changed, all
-new instances of that class will use the new thread pool.
-
-```ruby
-Concurrent::Agent.thread_pool == $GLOBAL_THREAD_POOL #=> true
-
-$GLOBAL_THREAD_POOL = Concurrent::FixedThreadPool.new(10) #=> #<Concurrent::FixedThreadPool:0x007fe31130f1f0 ...
-
-Concurrent::Agent.thread_pool == $GLOBAL_THREAD_POOL #=> false
-
-Concurrent::Defer.thread_pool = Concurrent::CachedThreadPool.new #=> #<Concurrent::CachedThreadPool:0x007fef1c6b6b48 ...
-Concurrent::Defer.thread_pool == Concurrent::Agent.thread_pool #=> false
-Concurrent::Defer.thread_pool == $GLOBAL_THREAD_POOL #=> false
-```
-
 ## Copyright
 
 *Concurrent Ruby* is Copyright &copy; 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).

data/spec/concurrent/agent_spec.rb

@@ -16,7 +16,7 @@ module Concurrent
     end
 
     before(:each) do
-      Agent.thread_pool = FixedThreadPool.new(1)
+      $GLOBAL_THREAD_POOL = CachedThreadPool.new
     end
 
     context '#initialize' do
@@ -38,7 +38,7 @@ module Concurrent
       end
 
       it 'spawns the worker thread' do
-        Agent.thread_pool.should_receive(:post).once.with(any_args())
+        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
         Agent.new(0)
       end
     end
@@ -92,8 +92,6 @@ module Concurrent
     context '#post' do
       
       it 'adds the given block to the queue' do
-        subject.post{ sleep(100) }
-        sleep(0.1)
         before = subject.length
         subject.post{ nil }
         subject.post{ nil }
@@ -101,8 +99,6 @@ module Concurrent
       end
 
       it 'does not add to the queue when no block is given' do
-        subject.post{ sleep(100) }
-        sleep(0.1)
         before = subject.length
         subject.post
         subject.post{ nil }
@@ -117,8 +113,6 @@ module Concurrent
       end
 
       it 'should increase by one for each #post' do
-        subject.post{ sleep(100) }
-        sleep(0.1)
         subject.post{ sleep }
         subject.post{ sleep }
         subject.post{ sleep }
@@ -381,6 +375,31 @@ module Concurrent
         sleep(0.1)
         observer.value.should eq 10
       end
+
+      it 'aliases #<< for Agent#post' do
+        subject << proc{ 100 }
+        sleep(0.1)
+        subject.value.should eq 100
+
+        subject << lambda{ 100 }
+        sleep(0.1)
+        subject.value.should eq 100
+      end
+
+      it 'aliases Kernel#agent for Agent.new' do
+        agent(10).should be_a(Agent)
+      end
+
+      it 'aliases Kernel#deref for #deref' do
+        deref(Agent.new(10)).should eq 10
+        deref(Agent.new(10), 10).should eq 10
+      end
+
+      it 'aliases Kernel:post for Agent#post' do
+        post(subject){ 100 }
+        sleep(0.1)
+        subject.value.should eq 100
+      end
     end
   end
 end