concurrent-ruby 0.1.1.pre.2 → 0.1.1.pre.3

data/lib/concurrent/thread_pool.rb

@@ -35,7 +35,7 @@ module Concurrent
     end
 
     def shutdown?
-      return ! running?
+      return @status == :shutdown
     end
 
     def killed?
@@ -44,8 +44,12 @@ module Concurrent
 
     def shutdown
       atomic {
-        @pool.size.times{ @queue << :stop }
-        @status = :shuttingdown
+        if @pool.empty?
+          @status = :shutdown
+        else
+          @status = :shuttingdown
+          @pool.size.times{ @queue << :stop }
+        end
       }
     end
 

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.1.1.pre.2'
+  VERSION = '0.1.1.pre.3'
 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`.
+a `Defer` can be considered a non-blocking `Future` or a simplified, non-blocking `Promise`. Defers run on the global thread pool.
 
 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,6 +28,8 @@ 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,6 +151,12 @@ $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))
@@ -167,6 +173,27 @@ 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

@@ -15,6 +15,10 @@ module Concurrent
       end.new
     end
 
+    before(:each) do
+      Agent.thread_pool = FixedThreadPool.new(1)
+    end
+
     context '#initialize' do
 
       it 'sets the value to the given initial state' do
@@ -34,7 +38,7 @@ module Concurrent
       end
 
       it 'spawns the worker thread' do
-        Thread.should_receive(:new).once.with(any_args())
+        Agent.thread_pool.should_receive(:post).once.with(any_args())
         Agent.new(0)
       end
     end

data/spec/concurrent/cached_thread_pool_spec.rb

@@ -10,6 +10,7 @@ module Concurrent
     it_should_behave_like 'Thread Pool'
 
     context '#initialize' do
+
       it 'aliases Concurrent#new_cached_thread_pool' do
         pool = Concurrent.new_cached_thread_pool
         pool.should be_a(CachedThreadPool)
@@ -108,5 +109,17 @@ module Concurrent
         subject.instance_variable_get(:@collector).status.should be_false
       end
     end
+
+    context '#status' do
+
+      it 'returns an empty collection when the pool is empty' do
+        subject.status.should be_empty
+      end
+
+      it 'returns one status object for each thread in the pool' do
+        3.times{ sleep(0.1); subject << proc{ sleep(0.5) } }
+        subject.status.length.should eq 3
+      end
+    end
   end
 end

data/spec/concurrent/defer_spec.rb

@@ -4,11 +4,11 @@ module Concurrent
 
   describe Defer do
 
-    context '#initialize' do
+    before(:each) do
+      Defer.thread_pool = FixedThreadPool.new(1)
+    end
 
-      before(:each) do
-        $GLOBAL_THREAD_POOL = FixedThreadPool.new(1)
-      end
+    context '#initialize' do
 
       it 'raises an exception if no block or operation given' do
         lambda {
@@ -24,22 +24,15 @@ module Concurrent
       end
 
       it 'starts the thread if an operation is given' do
-        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
+        Defer.thread_pool.should_receive(:post).once.with(any_args())
         operation = proc{ nil }
         Defer.new(op: operation)
       end
 
       it 'does not start the thread if neither a callback or errorback is given' do
-        $GLOBAL_THREAD_POOL.should_not_receive(:post)
+        Defer.thread_pool.should_not_receive(:post)
         Defer.new{ nil }
       end
-
-      it 'runs on the alternate thread pool if given' do
-        operation = proc{ nil }
-        pool = Concurrent::FixedThreadPool.new(2)
-        pool.should_receive(:post).with(no_args())
-        Defer.new(op: operation, pool: pool)
-      end
     end
 
     context '#then' do
@@ -126,14 +119,14 @@ module Concurrent
 
       it 'starts the thread if not started' do
         deferred = Defer.new{ nil }
-        $GLOBAL_THREAD_POOL.should_receive(:post).once.with(any_args())
+        Defer.thread_pool.should_receive(:post).once.with(any_args())
         deferred.go
       end
 
       it 'does nothing if called more than once' do
         deferred = Defer.new{ nil }
         deferred.go
-        $GLOBAL_THREAD_POOL.should_not_receive(:post)
+        Defer.thread_pool.should_not_receive(:post)
         deferred.go
       end
 
@@ -142,16 +135,9 @@ module Concurrent
         callback = proc{|result| nil }
         errorback = proc{|ex| nil }
         deferred = Defer.new(op: operation, callback: callback, errorback: errorback)
-        $GLOBAL_THREAD_POOL.should_not_receive(:post)
+        Defer.thread_pool.should_not_receive(:post)
         deferred.go
       end
-
-      it 'runs on the alternate thread pool if given' do
-        pool = Concurrent::FixedThreadPool.new(2)
-        pool.should_receive(:post).with(no_args())
-        deferred = Defer.new{ nil }
-        deferred.go(pool)
-      end
     end
 
     context 'fulfillment' do

data/spec/concurrent/event_machine_defer_proxy_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 require 'concurrent/agent'
 require 'concurrent/future'
+require 'concurrent/goroutine'
 require 'concurrent/promise'
 
 module Concurrent
@@ -70,8 +71,11 @@ module Concurrent
 
         subject { Agent.new(0) }
 
+        before(:each) do
+          Agent.thread_pool = EventMachineDeferProxy.new
+        end
+
         it 'supports fulfillment' do
-          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 
           EventMachine.run do
 
@@ -87,7 +91,6 @@ module Concurrent
         end
 
         it 'supports validation' do
-          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 
           EventMachine.run do
 
@@ -102,7 +105,6 @@ module Concurrent
         end
 
         it 'supports rejection' do
-          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 
           EventMachine.run do
 
@@ -122,8 +124,11 @@ module Concurrent
 
       context Future do
 
+        before(:each) do
+          Future.thread_pool = EventMachineDeferProxy.new
+        end
+
         it 'supports fulfillment' do
-          $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 
           EventMachine.run do
 
@@ -142,10 +147,13 @@ module Concurrent
 
       context Promise do
 
+        before(:each) do
+          Promise.thread_pool = EventMachineDeferProxy.new
+        end
+
         context 'fulfillment' do
 
           it 'passes all arguments to the first promise in the chain' do
-            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 
             EventMachine.run do
 
@@ -162,7 +170,6 @@ module Concurrent
           end
 
           it 'passes the result of each block to all its children' do
-            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 
             EventMachine.run do
               @expected = nil
@@ -176,7 +183,6 @@ module Concurrent
           end
 
           it 'sets the promise value to the result if its block' do
-            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 
             EventMachine.run do
 
@@ -193,7 +199,6 @@ module Concurrent
         context 'rejection' do
 
           it 'sets the promise reason and error on exception' do
-            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 
             EventMachine.run do
 
@@ -209,7 +214,6 @@ module Concurrent
           end
 
           it 'calls the first exception block with a matching class' do
-            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 
             EventMachine.run do
 
@@ -227,7 +231,6 @@ module Concurrent
           end
 
           it 'passes the exception object to the matched block' do
-            $GLOBAL_THREAD_POOL = EventMachineDeferProxy.new
 
             EventMachine.run do
 

data/spec/concurrent/executor_spec.rb

@@ -142,5 +142,43 @@ module Concurrent
         @level.should eq :error
       end
     end
+
+    context '#status' do
+
+      it 'returns the status of the executor thread when running' do
+        @ec = Executor.run('Foo'){ nil }
+        sleep(0.1)
+        @ec.status.should eq 'sleep'
+      end
+
+      it 'returns nil when not running' do
+        @ec = Executor.run('Foo'){ nil }
+        @ec.kill
+        sleep(0.1)
+        @ec.status.should be_nil
+      end
+    end
+
+    context '#join' do
+
+      it 'joins the executor thread when running' do
+        @ec = Executor.run('Foo'){ nil }
+        Thread.new{ sleep(1); @ec.kill }
+        @ec.join.should be_a(Thread)
+      end
+
+      it 'joins the executor thread with timeout when running' do
+        @ec = Executor.run('Foo'){ nil }
+        @ec.join(1).should be_nil
+      end
+
+      it 'immediately returns nil when not running' do
+        @ec = Executor.run('Foo'){ nil }
+        @ec.kill
+        sleep(0.1)
+        @ec.join.should be_nil
+        @ec.join(1).should be_nil
+      end
+    end
   end
 end

data/spec/concurrent/functions_spec.rb

@@ -2,8 +2,147 @@ require 'spec_helper'
 
 module Concurrent
 
+  describe 'functions' do
+
+    context '#post' do
+
+      it 'calls #post when supported by the object' do
+        object = Class.new{
+          def post() nil; end
+        }.new
+        object.should_receive(:post).with(no_args())
+        post(object){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          post(object){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context '#deref' do
+
+      it 'returns the value of the #deref function' do
+        object = Class.new{
+          def deref() nil; end
+        }.new
+        object.should_receive(:deref).with(nil)
+        deref(object, nil){ nil }
+      end
+
+      it 'returns the value of the #value function' do
+        object = Class.new{
+          def value() nil; end
+        }.new
+        object.should_receive(:value).with(nil)
+        deref(object, nil){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          deref(object, nil){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context '#pending?' do
+
+      it 'returns the value of the #pending? function' do
+        object = Class.new{
+          def pending?() nil; end
+        }.new
+        object.should_receive(:pending?).with(no_args())
+        pending?(object){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          pending?(object){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context '#fulfilled?' do
+
+      it 'returns the value of the #fulfilled? function' do
+        object = Class.new{
+          def fulfilled?() nil; end
+        }.new
+        object.should_receive(:fulfilled?).with(no_args())
+        fulfilled?(object){ nil }
+      end
+
+      it 'returns the value of the #realized? function' do
+        object = Class.new{
+          def realized?() nil; end
+        }.new
+        object.should_receive(:realized?).with(no_args())
+        fulfilled?(object){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          fulfilled?(object){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context '#realized?' do
+
+      it 'returns the value of the #realized? function' do
+        object = Class.new{
+          def realized?() nil; end
+        }.new
+        object.should_receive(:realized?).with(no_args())
+        realized?(object){ nil }
+      end
+
+      it 'returns the value of the #fulfilled? function' do
+        object = Class.new{
+          def fulfilled?() nil; end
+        }.new
+        object.should_receive(:fulfilled?).with(no_args())
+        realized?(object){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          realized?(object){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    context '#rejected?' do
+
+      it 'returns the value of the #rejected? function' do
+        object = Class.new{
+          def rejected?() nil; end
+        }.new
+        object.should_receive(:rejected?).with(no_args())
+        rejected?(object){ nil }
+      end
+
+      it 'raises an exception when not supported by the object' do
+        object = Class.new{ }.new
+        lambda {
+          rejected?(object){ nil }
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
   describe Agent do
 
+    before(:each) do
+      Agent.thread_pool = FixedThreadPool.new(1)
+    end
+
     it 'aliases #<< for Agent#post' do
       subject = Agent.new(0)
       subject << proc{ 100 }
@@ -30,13 +169,30 @@ module Concurrent
 
   describe Defer do
 
+    before(:each) do
+      Defer.thread_pool = FixedThreadPool.new(1)
+    end
+
     it 'aliases Kernel#defer' do
       defer{ nil }.should be_a(Defer)
     end
   end
 
+  describe Executor do
+
+    it 'aliases Kernel#executor' do
+      ex = executor('executor'){ nil }
+      ex.should be_a(Executor::ExecutionContext)
+      ex.kill
+    end
+  end
+
   describe Future do
 
+    before(:each) do
+      Future.thread_pool = FixedThreadPool.new(1)
+    end
+
     it 'aliases Kernel#future for Future.new' do
       future().should be_a(Future)
       future(){ nil }.should be_a(Future)
@@ -47,6 +203,10 @@ module Concurrent
 
   describe Promise do
 
+    before(:each) do
+      Promise.thread_pool = FixedThreadPool.new(1)
+    end
+
     it 'aliases Kernel#promise for Promise.new' do
       promise().should be_a(Promise)
       promise(){ nil }.should be_a(Promise)