concurrent-ruby 0.2.2 → 0.3.0.pre.1

data/lib/concurrent/thread_pool.rb

@@ -1,19 +1,7 @@
-require 'functional/behavior'
+require 'thread'
+require 'functional'
 
 require 'concurrent/event'
-require 'concurrent/utilities'
-
-behavior_info(:thread_pool,
-              running?: 0,
-              shutdown?: 0,
-              killed?: 0,
-              shutdown: 0,
-              kill: 0,
-              size: 0,
-              wait_for_termination: -1,
-              post: -1,
-              :<< => 1,
-              status: 0)
 
 behavior_info(:global_thread_pool,
               post: -1,
@@ -21,44 +9,49 @@ behavior_info(:global_thread_pool,
 
 module Concurrent
 
-  class ThreadPool
+  class AbstractThreadPool
 
-    def initialize
-      @status = :running
-      @queue = Queue.new
-      @termination = Event.new
-      @pool = []
-    end
+    WorkerContext = Struct.new(:status, :idletime, :thread)
 
-    def running?
-      return @status == :running
-    end
+    MIN_POOL_SIZE = 1
+    MAX_POOL_SIZE = 256
 
-    def shutdown?
-      return @status == :shutdown
+    attr_accessor :max_threads
+
+    def initialize(opts = {})
+      @max_threads = opts[:max_threads] || opts[:max] || MAX_POOL_SIZE
+      if @max_threads < MIN_POOL_SIZE || @max_threads > MAX_POOL_SIZE
+        raise ArgumentError.new("pool size must be from #{MIN_POOL_SIZE} to #{MAX_POOL_SIZE}")
+      end
+
+      @state = :running
+      @mutex ||= Mutex.new
+      @terminator ||= Event.new
+      @pool ||= []
+      @queue ||= Queue.new
+      @working = 0
     end
 
-    def killed?
-      return @status == :killed
+    def running?
+      return @state == :running
     end
 
     def shutdown
-      mutex.synchronize do
+      @mutex.synchronize do
+        @collector.kill if @collector && @collector.status
         if @pool.empty?
-          @status = :shutdown
+          @state = :shutdown
+          @terminator.set
         else
-          @status = :shuttingdown
+          @state = :shuttingdown
           @pool.size.times{ @queue << :stop }
         end
       end
+      Thread.pass
     end
 
     def wait_for_termination(timeout = nil)
-      if shutdown? || killed?
-        return true
-      else
-        return @termination.wait(timeout)
-      end
+      return @terminator.wait(timeout)
     end
 
     def <<(block)
@@ -66,11 +59,91 @@ module Concurrent
       return self
     end
 
+    def kill
+      @mutex.synchronize do
+        @collector.kill if @collector && @collector.status
+        @state = :shuttingdown
+        @pool.each{|t| Thread.kill(t.thread) }
+        @terminator.set
+      end
+      Thread.pass
+    end
+
+    def size
+      return @mutex.synchronize do
+        @state == :running ? @pool.length : 0
+      end 
+    end
+    alias_method :length, :size
+
+    def status
+      @mutex.synchronize do
+        @pool.collect do |worker|
+          [
+            worker.status,
+            worker.status == :idle ? delta(worker.idletime, timestamp) : nil,
+            worker.thread.status
+          ]
+        end
+      end
+    end
+
     protected
 
-    # @private
-    def mutex # :nodoc:
-      @mutex || Mutex.new
+    def timestamp
+      return Time.now.to_i
+    end
+
+    private
+
+    def create_worker_thread
+      context = WorkerContext.new(:idle, timestamp, nil)
+
+      context.thread = Thread.new do
+        Thread.current.abort_on_exception = false
+        loop do
+          task = @queue.pop
+          if task == :stop
+            @mutex.synchronize do
+              context.status = :stopping
+            end
+            break
+          else
+            @mutex.synchronize do
+              context.status = :working
+              @working += 1
+            end
+            task.last.call(*task.first)
+            @mutex.synchronize do
+              @working -= 1
+              context.status = :idle
+              context.idletime = timestamp
+            end
+          end
+        end
+        @mutex.synchronize do
+          @pool.delete(context)
+          if @pool.empty? && @state != :running
+            @terminator.set
+            @state = :shutdown
+          end
+        end
+      end
+
+      Thread.pass
+      run_garbage_collector unless @collector && @collector.alive?
+      return context
+    end
+
+    def run_garbage_collector
+      @collector = Thread.new do
+        Thread.current.abort_on_exception = false
+        loop do
+          sleep(1)
+          @mutex.synchronize { collect_garbage }
+        end
+      end
+      Thread.pass
     end
   end
 end

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.2.2'
+  VERSION = '0.3.0.pre.1'
 end

data/md/executor.md

@@ -21,10 +21,16 @@ One other advantage of the `Executor` class is that it forces the bsiness logic
 be completely decoupled from the threading logic. The business logic can be tested
 separately then passed to the an executor for scheduling and running.
 
+The `Executor` is the yin to to the
+[Supervisor's](https://github.com/jdantonio/concurrent-ruby/blob/master/md/supervisor.md)
+yang. Where the `Supervisor` is intended to manage long-running threads that operate
+continuously, the `Executor` is intended to manage fairly short operations that
+occur repeatedly at regular intervals.
+
 Unlike some of the others concurrency objects in the library, executors do not
-run on the global. In my experience the types of tasks that will benefit from
-the `Executor` class tend to also be long running. For this reason they get their
-own thread every time the task is executed.
+run on the global thread pool. In my experience the types of tasks that will benefit
+from the `Executor` class tend to also be long running. For this reason they get
+their own thread every time the task is executed.
 
 ## ExecutionContext
 

data/md/goroutine.md

@@ -11,15 +11,17 @@ for processing.
 ```ruby
 require 'concurrent'
 
-@expected = nil
-
-go(1, 2, 3){|a, b, c| sleep(1); @expected = [c, b, a] }
-
-sleep(0.1)
-@expected #=> nil
-
-sleep(2)
-@expected #=> [3, 2, 1]
+go('foo'){|echo| sleep(0.1); print "#{echo}\n"; sleep(0.1); print "Boom!\n" }
+go('bar'){|echo| sleep(0.1); print "#{echo}\n"; sleep(0.1); print "Pow!\n" }
+go('baz'){|echo| sleep(0.1); print "#{echo}\n"; sleep(0.1); print "Zap!\n" }
+sleep(0.5)
+
+#=> foo
+#=> bar
+#=> baz
+#=> Boom!
+#=> Pow!
+#=> Zap!
 ```
 
 ## Copyright

data/md/reactor.md

@@ -0,0 +1,32 @@
+# Event
+
+TBD...
+
+## Copyright
+
+*Concurrent Ruby* is Copyright © 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
+It is free software and may be redistributed under the terms specified in the LICENSE file.
+
+## License
+
+Released under the MIT license.
+
+http://www.opensource.org/licenses/mit-license.php  
+
+> Permission is hereby granted, free of charge, to any person obtaining a copy  
+> of this software and associated documentation files (the "Software"), to deal  
+> in the Software without restriction, including without limitation the rights  
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
+> copies of the Software, and to permit persons to whom the Software is  
+> furnished to do so, subject to the following conditions:  
+> 
+> The above copyright notice and this permission notice shall be included in  
+> all copies or substantial portions of the Software.  
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
+> THE SOFTWARE.  

data/md/supervisor.md

@@ -0,0 +1,43 @@
+# You don't need to get no supervisor! You the supervisor today!
+
+TBD...
+
+The `Sypervisor` is the yin to to the
+[Executor's](https://github.com/jdantonio/concurrent-ruby/blob/master/md/executor.md)
+yang. Where the `Supervisor` is intended to manage long-running threads that operate
+continuously, the `Executor` is intended to manage fairly short operations that
+occur repeatedly at regular intervals.
+
+* [Supervisor Module](http://www.erlang.org/doc/man/supervisor.html)
+* [Supervisor Behaviour](http://www.erlang.org/doc/design_principles/sup_princ.html)
+* [Who Supervises The Supervisors?](http://learnyousomeerlang.com/supervisors)
+* [OTP Design Principles](http://www.erlang.org/doc/design_principles/des_princ.html)
+
+## Copyright
+
+*Concurrent Ruby* is Copyright © 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
+It is free software and may be redistributed under the terms specified in the LICENSE file.
+
+## License
+
+Released under the MIT license.
+
+http://www.opensource.org/licenses/mit-license.php  
+
+> Permission is hereby granted, free of charge, to any person obtaining a copy  
+> of this software and associated documentation files (the "Software"), to deal  
+> in the Software without restriction, including without limitation the rights  
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
+> copies of the Software, and to permit persons to whom the Software is  
+> furnished to do so, subject to the following conditions:  
+> 
+> The above copyright notice and this permission notice shall be included in  
+> all copies or substantial portions of the Software.  
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
+> THE SOFTWARE.  

data/spec/concurrent/agent_spec.rb

@@ -30,21 +30,12 @@ module Concurrent
       end
 
       it 'sets the timeout to the given value' do
-        Agent.new(0, 5).timeout.should eq 5
+        Agent.new(0, timeout: 5).timeout.should eq 5
       end
 
       it 'sets the timeout to the default when nil' do
         Agent.new(0).timeout.should eq Agent::TIMEOUT
       end
-
-      it 'sets the length to zero' do
-        Agent.new(10).length.should eq 0
-      end
-
-      it 'spawns the worker thread' do
-        Agent.thread_pool.should_receive(:post).once.with(any_args())
-        Agent.new(0)
-      end
     end
 
     context '#rescue' do
@@ -96,45 +87,19 @@ module Concurrent
     context '#post' do
       
       it 'adds the given block to the queue' do
+        Agent.thread_pool.should_receive(:post).with(no_args()).exactly(3).times
         subject.post{ sleep(100) }
-        sleep(0.1)
-        before = subject.length
         subject.post{ nil }
         subject.post{ nil }
-        subject.length.should eq before+2
+        sleep(0.1)
       end
 
       it 'does not add to the queue when no block is given' do
+        Agent.thread_pool.should_receive(:post).with(no_args()).exactly(2).times
         subject.post{ sleep(100) }
-        sleep(0.1)
-        before = subject.length
         subject.post
         subject.post{ nil }
-        subject.length.should eq before+1
-      end
-    end
-
-    context '#length' do
-
-      it 'should be zero for a new agent' do
-        subject.length.should eq 0
-      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 }
-        subject.length.should eq 3
-      end
-
-      it 'should decrease by one each time a handler is run' do
-        subject.post{ nil }
-        subject.post{ sleep }
-        subject.post{ sleep }
-        sleep(0.1)
-        subject.length.should eq 1
       end
     end
 
@@ -163,7 +128,7 @@ module Concurrent
       end
 
       it 'rejects the handler after timeout reached' do
-        agent = Agent.new(0, 0.1)
+        agent = Agent.new(0, timeout: 0.1)
         agent.post{ sleep(1); 10 }
         agent.value.should eq 0
       end
@@ -238,7 +203,7 @@ module Concurrent
         subject.
           rescue(ArgumentError){|ex| @expected = 1 }.
           rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
+          rescue(StandardError){|ex| @expected = 3 }
         subject.post{ raise ArgumentError }
         sleep(0.1)
         @expected.should eq 1
@@ -247,7 +212,7 @@ module Concurrent
         subject.
           rescue(ArgumentError){|ex| @expected = 1 }.
           rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
+          rescue(StandardError){|ex| @expected = 3 }
         subject.post{ raise LoadError }
         sleep(0.1)
         @expected.should eq 2
@@ -256,7 +221,7 @@ module Concurrent
         subject.
           rescue(ArgumentError){|ex| @expected = 1 }.
           rescue(LoadError){|ex| @expected = 2 }.
-          rescue(Exception){|ex| @expected = 3 }
+          rescue(StandardError){|ex| @expected = 3 }
         subject.post{ raise StandardError }
         sleep(0.1)
         @expected.should eq 3
@@ -267,7 +232,7 @@ module Concurrent
         subject.
           rescue(ArgumentError){|ex| @expected = ex }.
           rescue(LoadError){|ex| @expected = ex }.
-          rescue(Exception){|ex| @expected = ex }
+          rescue(StandardError){|ex| @expected = ex }
         subject.post{ raise StandardError }
         sleep(0.1)
         @expected.should be_a(StandardError)
@@ -275,11 +240,9 @@ module Concurrent
 
       it 'ignores rescuers without a block' do
         @expected = nil
-        subject.
+        Promise.new{ raise StandardError }.
           rescue(StandardError).
-          rescue(StandardError){|ex| @expected = ex }.
-          rescue(Exception){|ex| @expected = ex }
-        subject.post{ raise StandardError }
+          rescue(StandardError){|ex| @expected = ex }
         sleep(0.1)
         @expected.should be_a(StandardError)
       end
@@ -288,8 +251,8 @@ module Concurrent
         lambda {
           subject.
             rescue(ArgumentError){|ex| @expected = ex }.
-            rescue(StandardError){|ex| @expected = ex }.
-            rescue(Exception){|ex| @expected = ex }
+            rescue(NotImplementedError){|ex| @expected = ex }.
+            rescue(NoMethodError){|ex| @expected = ex }
           subject.post{ raise StandardError }
           sleep(0.1)
         }.should_not raise_error
@@ -297,13 +260,109 @@ module Concurrent
 
       it 'supresses exceptions thrown from rescue handlers' do
         lambda {
-          subject.rescue(Exception){ raise StandardError }
+          subject.rescue(StandardError){ raise StandardError }
           subject.post{ raise ArgumentError }
           sleep(0.1)
         }.should_not raise_error
       end
     end
 
+    context 'dereference' do
+
+      it 'defaults :dup_on_deref to false' do
+        value = 'value'
+        value.should_not_receive(:dup).with(any_args())
+
+        agent = Agent.new(value)
+        agent.value.should eq 'value'
+
+        agent = Agent.new(value, dup_on_deref: false)
+        agent.value.should eq 'value'
+
+        agent = Agent.new(value, dup: false)
+        agent.value.should eq 'value'
+      end
+
+      it 'calls #dup when the :dup_on_deref option is true' do
+        value = 'value'
+        
+        agent = Agent.new(value, dup_on_deref: true)
+        agent.value.object_id.should_not eq value.object_id
+        agent.value.should eq 'value'
+
+        agent = Agent.new(value, dup: true)
+        agent.value.object_id.should_not eq value.object_id
+        agent.value.should eq 'value'
+      end
+
+      it 'defaults :freeze_on_deref to false' do
+        value = 'value'
+        value.should_not_receive(:freeze).with(any_args())
+
+        agent = Agent.new(value)
+        agent.value.should eq 'value'
+
+        agent = Agent.new(value, freeze_on_deref: false)
+        agent.value.should eq 'value'
+
+        agent = Agent.new(value, freeze: false)
+        agent.value.should eq 'value'
+      end
+
+      it 'calls #freeze when the :freeze_on_deref option is true' do
+        value = 'value'
+
+        agent = Agent.new(value, freeze_on_deref: true)
+        agent.value.should be_frozen
+        agent.value.should eq 'value'
+
+        agent = Agent.new(value, freeze: true)
+        agent.value.should be_frozen
+        agent.value.should eq 'value'
+      end
+
+      it 'defaults :copy_on_deref to nil' do
+        value = 'value'
+
+        agent = Agent.new(value)
+        agent.value.object_id.should == value.object_id
+        agent.value.should eq 'value'
+
+        agent = Agent.new(value, copy_on_deref: nil)
+        agent.value.object_id.should == value.object_id
+        agent.value.should eq 'value'
+
+        agent = Agent.new(value, copy: nil)
+        agent.value.object_id.should == value.object_id
+        agent.value.should eq 'value'
+      end
+
+      it 'calls the block when the :copy_on_deref option is passed a proc' do
+        value = 'value'
+        copy = proc{|val| 'copy' }
+
+        agent = Agent.new(value, copy_on_deref: copy)
+        agent.value.object_id.should_not == value.object_id
+
+        agent = Agent.new(value, copy: copy)
+        agent.value.object_id.should_not == value.object_id
+      end
+
+      it 'calls the :copy block first followed by #dup followed by #freeze' do
+        value = 'value'
+        copied = 'copied'
+        dup = 'dup'
+        frozen = 'frozen'
+        copy = proc{|val| copied }
+
+        copied.should_receive(:dup).with(no_args()).and_return(dup)
+        dup.should_receive(:freeze).with(no_args()).and_return(frozen)
+
+        agent = Agent.new(value, dup_on_deref: true, freeze_on_deref: true, copy_on_deref: copy)
+        agent.value.should eq frozen
+      end
+    end
+
     context 'observation' do
 
       it 'notifies all observers when the value changes' do
@@ -386,5 +445,23 @@ module Concurrent
         observer.value.should eq 10
       end
     end
+
+    context 'stress test' do
+
+      before(:each) do
+        Agent.thread_pool = FixedThreadPool.new(5)
+      end
+
+      specify do
+        count = 10_000
+        counter = Concurrent::Agent.new(0)
+
+        count.times do |i|
+          counter.post{|value| value + 1 }
+        end
+
+        sleep(0.1) until counter.value == count
+      end
+    end
   end
 end