ActionPool 0.1.0 → 0.2.0

data/CHANGELOG

@@ -0,0 +1,6 @@
+0.2.0
+    - Added argument support for passed tasks (thanks simonmenke)
+    - Faster pool resizing
+    - Smarter thread creation to limit unneeded creation
+    - Allow floats for timeouts to provide better control
+    - Test verified support for 1.8.6, 1.8.7, 1.9.1 and JRuby 1.4.0RC1

data/README.rdoc

@@ -1,6 +1,6 @@
 == ActionPool
 
-ActionPool is just a simple thread pool. It allows for various contraints and resizing in a pretty easy and unobtrusive manner. You can set limits on how long tasks are worked on, as well as on the life of a thread. For things that like to use lots threads, it can be helpful to reuse threads instead of constantly recreating them.
+ActionPool is just a simple thread pool. It allows for various constraints and resizing in a pretty easy and unobtrusive manner. You can set limits on how long tasks are worked on, as well as on the life of a thread. For things that like to use lots threads, it can be helpful to reuse threads instead of constantly recreating them.
 
 === install (easy):
 
@@ -121,7 +121,7 @@ Which results in:
     Thread: #<Thread:0x86c1080>
     Thread pool woke me up: Wakeup main thread
 
-Our pool starts with a single thread that is occupied by the sleeping task waiting to raise an exception. As we begin to add new tasks, the pool grows to accommidate the growing number of tasks, until it reaches the maximum threshold of 3. At that point, the pool simply processes the tasks until the task list is empty.
+Our pool starts with a single thread that is occupied by the sleeping task waiting to raise an exception. As we begin to add new tasks, the pool grows to accommodate the growing number of tasks, until it reaches the maximum threshold of 3. At that point, the pool simply processes the tasks until the task list is empty.
 
 The pool also has the ability to limit the amount of time a thread spends working on a given task. By default, a thread will work on a given task until the task is completed, or the pool is shutdown. However, as the following example shows, it is very easy to limit this time to avoid the pool being bogged down on long running tasks:
 
@@ -158,16 +158,33 @@ If you have a number of tasks you would like to schedule at once, it is easy wit
     lock = Mutex.new
     tasks = [].fill(lambda{ lock.synchronize{ a += 1 } }, 0..19)
     pool.add_jobs(tasks)
-    sleep(0.5)
+    pool.shutdown
     puts "Result: #{a}"
 
 Results:
 
     Result: 20
 
-=== Footer
+Passing arguments to tasks is now available as well:
 
-I hope this library is useful. If you find any bugs, or need any help, you can find me on DALnet and Freenode.
+    require 'actionpool'
+
+    pool = ActionPool::Pool.new
+    string = 'Hello world'
+    puts "Original: #{string}. ID: #{string.object_id}"
+    pool << [lambda{|var| puts "Passed: #{var}. ID: #{var.object_id}"}, [string.dup]]
+    pool << [lambda{|a,b| puts "Passed: #{a} | #{b}. ID: #{a.object_id} | #{b.object_id}"}, [string, string.dup]]
+    pool.shutdown
+
+Results:
+
+    Original: Hello world. ID: 70651630
+    Passed: Hello world. ID: 70651250
+    Passed: Hello world | Hello world. ID: 70651630 | 70651100
+
+== Last remarks
+
+If you find any bugs, please report them through {github}[http://github.com/spox/actionpool/issues]. If you are in need of any help, you can generally find me on DALnet and Freenode.
 
 == License
 

data/actionpool.gemspec

@@ -2,12 +2,12 @@ spec = Gem::Specification.new do |s|
     s.name              = 'ActionPool'
     s.author            = %q(spox)
     s.email             = %q(spox@modspox.com)
-    s.version           = '0.1.0'
+    s.version           = '0.2.0'
     s.summary           = %q(Thread Pool)
     s.platform          = Gem::Platform::RUBY
     s.files             = Dir['**/*']
     s.rdoc_options      = %w(--title ActionPool --main README.rdoc --line-numbers)
-    s.extra_rdoc_files  = %w(README.rdoc)
+    s.extra_rdoc_files  = %w(README.rdoc CHANGELOG)
     s.require_paths     = %w(lib)
     s.required_ruby_version = '>= 1.8.6'
     s.homepage          = %q(http://github.com/spox/actionpool)
@@ -20,4 +20,4 @@ spec = Gem::Specification.new do |s|
         end
     end
     s.description = description[1..-1].join(" ")
-end
+end

data/lib/actionpool.rb

@@ -1 +1,7 @@
+begin
+    require 'fastthread'
+rescue LoadError
+    # we don't care if it's available
+    # just load it if it's around
+end
 require 'actionpool/Pool'

data/lib/actionpool/LogHelper.rb

@@ -1,9 +1,8 @@
-require 'logger'
-
 module ActionPool
     class LogHelper
     
         def initialize(logger=nil)
+            require 'logger'
             @logger = logger
         end
 

data/lib/actionpool/Pool.rb

@@ -17,50 +17,69 @@ module ActionPool
             @logger = LogHelper.new(args[:logger])
             @queue = ActionPool::Queue.new
             @threads = []
-            @thread_timeout = args[:t_to] ? args[:t_to] : 60
-            @action_timeout = args[:a_to] ? args[:a_to] : nil
+            @lock = Mutex.new
+            @thread_timeout = args[:t_to] ? args[:t_to] : 0
+            @action_timeout = args[:a_to] ? args[:a_to] : 0
             @min_threads = args[:min_threads] ? args[:min_threads] : 10
             @max_threads = args[:max_threads] ? args[:max_threads] : 100
             @respond_to = ::Thread.current
-            @min_threads.times{create_thread}
+            create_thread
         end
 
         # force:: force creation of a new thread
         # Create a new thread for pool. Returns newly created ActionPool::Thread or
         # nil if pool has reached maximum threads
         def create_thread(force=false)
-            return nil unless @threads.size < @max_threads || force
-            @logger.info('Pool is creating a new thread')
-            pt = ActionPool::Thread.new(:pool => self, :respond_thread => @respond_to, :a_timeout => @action_timeout, :t_timeout => @thread_timeout, :logger => @logger)
-            @threads << pt
+            pt = nil
+            @lock.synchronize do
+                if(@threads.size < @max_threads || force)
+                    @logger.info('Pool is creating a new thread')
+                    (min - size > 0 ? min - size : 1).times do |i|
+                        pt = ActionPool::Thread.new(:pool => self, :respond_thread => @respond_to, :a_timeout => @action_timeout, :t_timeout => @thread_timeout, :logger => @logger)
+                        @threads << pt
+                    end
+                else
+                    @logger.info('Pool is at maximum size. Not creating new thread')
+                end
+            end
             return pt
         end
 
         # force:: force immediate stop
         # Stop the pool
         def shutdown(force=false)
+            args = [:wait]
+            args += [:force] if force
             @logger.info("Pool is now shutting down #{force ? 'using force' : ''}")
-            @threads.each{|t|t.stop(force)}
-            until(size < 1) do
-                @queue << lambda{}
-                sleep(0.1)
+            @queue.wait_empty
+            while(t = @threads.pop) do
+                t.stop(*args)
             end
             nil
         end
 
-        # action:: proc to be executed
+        # action:: proc to be executed or array of [proc, [*args]]
         # Add a new proc/lambda to be executed (alias for queue)
         def <<(action)
-            queue(action)
+            case action
+                when Proc
+                    queue(action)
+                when Array
+                    raise ArgumentError.new('Actions to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]') unless action.size == 2 and action[0].is_a?(Proc) and action[1].is_a?(Array)
+                    queue(*action.flatten)
+                else
+                    raise ArgumentError.new('Actions to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]')
+            end
             nil
         end
 
         # action:: proc to be executed
         # Add a new proc/lambda to be executed
-        def queue(action)
+        def queue(action, *args)
             raise ArgumentError.new('Expecting block') unless action.is_a?(Proc)
-            @queue << action
-            create_thread if @queue.length > 0 && @queue.num_waiting < 1 # only start a new thread if we need it
+            @queue << [action, args]
+            ::Thread.pass
+            create_thread if @queue.num_waiting < 1 # only start a new thread if we need it
         end
 
         # jobs:: Array of proc/lambdas
@@ -70,11 +89,18 @@ module ActionPool
             @queue.pause
             begin
                 jobs.each do |job|
-                    raise ArgumentError.new('Jobs to be processed by the pool must be a proc/lambda') unless job.is_a?(Proc)
-                    @queue << job
+                    case job
+                    when Proc
+                        @queue << [job, []]
+                    when Array
+                        raise ArgumentError.new('Jobs to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]') unless job.size == 2 and job[0].is_a?(Proc) and job[1].is_a?(Array)
+                        @queue << job
+                    else
+                        raise ArgumentError.new('Jobs to be processed by the pool must be a proc/lambda or [proc/lambda, [*args]]')
+                    end
                 end
             ensure
-                while(create_thread)do;end; # make sure we get our pool population up
+                create_thread
                 @queue.unpause
             end
             true
@@ -82,8 +108,8 @@ module ActionPool
 
         # block:: block to process
         # Adds a block to be processed
-        def process(&block)
-            queue(block)
+        def process(*args, &block)
+            queue(block, *args)
             nil
         end
 
@@ -108,6 +134,7 @@ module ActionPool
             m = m.to_i
             raise ArgumentError.new('Maximum value must be greater than 0') unless m > 0
             @max_threads = m
+            resize if m < size
             m
         end
 
@@ -117,13 +144,14 @@ module ActionPool
             m = m.to_i
             raise ArgumentError.new("Minimum value must be greater than 0 and less than or equal to maximum (#{max})") unless m > 0 && m <= max
             @min_threads = m
-            resize if m < size
             m
         end
 
         # t:: ActionPool::Thread to remove
         # Removes a thread from the pool
         def remove(t)
+            raise ArgumentError.new('Expecting an ActionPool::Thread object') unless t.is_a?(ActionPool::Thread)
+            t.stop
             if(@threads.include?(t))
                 @threads.delete(t)
                 return true
@@ -150,9 +178,10 @@ module ActionPool
         # t:: timeout in seconds (nil for infinite)
         # Set maximum allowed time thead may idle in pool
         def thread_timeout=(t)
-            t = to_i unless t.nil?
-            raise ArgumentError.new('Value must be great than zero or nil') unless t.nil? || t > 0
+            t = t.to_f
+            raise ArgumentError.new('Value must be great than zero or nil') unless t > 0
             @thread_timeout = t
+            @threads.each{|thread|thread.thread_timeout = t}
             t
         end
 
@@ -160,9 +189,10 @@ module ActionPool
         # Set maximum allowed time thread may work
         # on a given action
         def action_timeout=(t)
-            t = to_i unless t.nil?
-            raise ArgumentError.new('Value must be great than zero or nil') unless t.nil? || t > 0
+            t = t.to_f
+            raise ArgumentError.new('Value must be great than zero or nil') unless t > 0
             @action_timeout = t
+            @threads.each{|thread|thread.action_timeout = t}
             t
         end
 
@@ -176,14 +206,30 @@ module ActionPool
             @queue.size
         end
 
+        # Flush the thread pool. Mainly used for forcibly resizing
+        # the pool if existing threads have a long thread life waiting
+        # for input.
+        def flush
+            lock = Mutex.new
+            guard = ConditionVariable.new
+            @threads.size.times{ queue{ lock.synchronize{ guard.wait(lock) } } }
+            Thread.pass
+            sleep(0.01)
+            lock.synchronize{ guard.broadcast }
+        end
+
         private
-        
+
+        # Resize the pool
         def resize
-            @logger.info("Pool is being resized to stated minimum: #{min}")
-            size - min.times do
-                t = @threads.shift
+            @logger.info("Pool is being resized to stated maximum: #{max}")
+            until(size <= max) do
+                t = nil
+                t = @threads.find{|t|t.waiting?}
+                t = @threads.shift unless t
                 t.stop
             end
+            flush
             nil
         end
     end

data/lib/actionpool/Queue.rb

@@ -9,6 +9,8 @@ module ActionPool
             @wait = false
             @lock = Mutex.new
             @guard = ConditionVariable.new
+            @elock = Mutex.new
+            @eguard = ConditionVariable.new
         end
         # Stop the queue from returning results to requesting
         # threads. Threads will wait for results until signalled
@@ -19,12 +21,18 @@ module ActionPool
         # will have results given to them.
         def unpause
             @wait = false
-            @lock.synchronize{ @guard.signal }
+            @lock.synchronize{ @guard.broadcast }
         end
         # Check if queue needs to wait before returning
         def pop
             @lock.synchronize{ @guard.wait(@lock) } if @wait
-            super
+            o = super
+            @elock.synchronize{ @eguard.broadcast } if empty?
+            return o
+        end
+        # Park a thread here until queue is empty
+        def wait_empty
+            @elock.synchronize{ @eguard.wait(@elock) } if size > 0
         end
     end
 end

data/lib/actionpool/Thread.rb

@@ -1,6 +1,7 @@
 require 'timeout'
 
 module ActionPool
+
     class Thread
         # :pool:: pool thread is associated with
         # :t_timeout:: max time a thread is allowed to wait for action
@@ -14,23 +15,74 @@ module ActionPool
             raise ArgumentError.new('ActionPool::Thread requries thread to respond') unless args[:respond_thread]
             @pool = args[:pool]
             @respond_to = args[:respond_thread]
-            @thread_timeout = args[:t_timeout] ? args[:t_timeout] : 0
-            @action_timeout = args[:a_timeout] ? args[:a_timeout] : 0
+            @thread_timeout = args[:t_timeout] ? args[:t_timeout].to_f : 0
+            @action_timeout = args[:a_timeout] ? args[:a_timeout].to_f : 0
             @kill = false
             @logger = args[:logger].is_a?(LogHelper) ? args[:logger] : LogHelper.new(args[:logger])
             @thread = ::Thread.new{ start_thread }
         end
 
-        # force:: force the thread to stop
+        # :force:: force the thread to stop
+        # :wait:: wait for the thread to stop
         # Stop the thread
-        def stop(force=false)
+        def stop(*args)
             @kill = true
-            @thread.kill if force
+            @thread.kill if args.include?(:force) || waiting?
+            # killing the thread if it is waiting? is a simple race condition
+            # in that, if the thread has just finished a task, but hasn't
+            # dropped by the queue line yet, we will see it as not waiting. we
+            # can counter that by waiting just a little bit longer than the allowed
+            # time to work on an action, and kill the thread if it is still around
+            if(args.include?(:wait))
+                unless(@thread.join(@action_timeout + 0.01))
+                    @thread.kill
+                    @thread.join
+                end
+            end
             nil
         end
 
+        # Is the thread still alive
+        def alive?
+            @thread.alive?
+        end
+
+        # Is the thread currently waiting for input
+        def waiting?
+            @thread.status == 'sleep'
+        end
+
+        # Seconds thread will wait for input
+        def thread_timeout
+            @thread_timeout
+        end
+
+        # Seconds thread will spend working on a given task
+        def action_timeout
+            @action_timeout
+        end
+
+        # t:: seconds to wait for input (floats allow for values 0 < t < 1)
+        # Set the maximum amount of time to wait for a task
+        def thread_timeout=(t)
+            t = t.to_f
+            raise ArgumentError.new('Value must be great than zero or nil') unless t > 0
+            @thread_timeout = t
+            t
+        end
+
+        # t:: seconds to work on a task (floats allow for values 0 < t < 1)
+        # Set the maximum amount of time to work on a given task
+        def action_timeout=(t)
+            t = t.to_f
+            raise ArgumentError.new('Value must be great than zero or nil') unless t > 0
+            @action_timeout = t
+            t
+        end
+
         private
 
+        # Start our thread
         def start_thread
             begin
                 @logger.info("New pool thread is starting (#{self})")
@@ -44,7 +96,7 @@ module ActionPool
                         else
                             action = @pool.action
                         end
-                        run(action) unless action.nil?
+                        run(*action) unless action.nil?
                     rescue Timeout::Error => boom
                         @kill = true
                     rescue Exception => boom
@@ -61,14 +113,17 @@ module ActionPool
             end
         end
 
-        def run(action)
+        # action:: task to be run
+        # args:: arguments to be passed to task
+        # Run the task
+        def run(action, args)
             begin
                 if(@action_timeout > 0)
                     Timeout::timeout(@action_timeout) do
-                        action.call
+                        action.call(*args)
                     end
                 else
-                    action.call
+                    action.call(*args)
                 end
             rescue Timeout::Error => boom
                 @logger.warn("Pool thread reached max execution time for action: #{boom}")

data/tests/cases/general.rb

@@ -0,0 +1,42 @@
+require 'actionpool'
+require 'test/unit'
+
+class GeneralPoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def test_numbers
+        assert_equal(10, @pool.size)
+        assert_equal(10, @pool.min)
+        assert_equal(100, @pool.max)
+        assert_equal(0, @pool.action_timeout)
+        assert_equal(0, @pool.thread_timeout)
+        assert_equal(0, @pool.action_size)
+    end
+    def test_output
+        a = 0
+        lock = Mutex.new
+        run = lambda{ lock.synchronize{ a += 1 } }
+        100.times{ @pool << run }
+        @pool.shutdown
+        assert_equal(100, a)
+        a = 0
+        jobs = [].fill(run,0,100)
+        @pool.add_jobs(jobs)
+        @pool.shutdown
+        assert_equal(100, a)
+        @pool.shutdown(true)
+    end
+    def test_args
+        output = nil
+        @pool << [lambda{|x| output = x}, [2]]
+        assert(2, output)
+        @pool.add_jobs([[lambda{|x| output = x}, [3]]])
+        assert(3, output)
+        output = []
+        @pool.add_jobs([[lambda{|x,y| output << x + y}, [1,1]], [lambda{|x| output << x}, [3]]])
+        assert(output.include?(2))
+        assert(output.include?(3))
+        @pool.shutdown(true)
+    end
+end

data/tests/cases/grow.rb

@@ -0,0 +1,20 @@
+require 'actionpool'
+require 'test/unit'
+
+class GrowPoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def test_grow
+        jobs = [].fill(lambda{}, 0..99)
+        @pool.add_jobs(jobs)
+        assert(@pool.size > 10)
+        @pool.shutdown(true)
+    end
+    def test_max
+        @pool.create_thread(true) until @pool.size > @pool.max
+        assert_nil(@pool.create_thread)
+        assert(@pool.create_thread(true))
+        @pool.shutdown(true)
+    end
+end

data/tests/cases/nogrow.rb

@@ -0,0 +1,12 @@
+require 'actionpool'
+require 'test/unit'
+
+class NoGrowPoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def test_nogrow
+        5.times{ @pool << lambda{} }
+        assert_equal(10, @pool.size)
+    end
+end

data/tests/cases/queue.rb

@@ -0,0 +1,34 @@
+require 'actionpool'
+require 'test/unit'
+
+class QueueTest < Test::Unit::TestCase
+    def setup
+        @queue = ActionPool::Queue.new
+    end
+    def test_pop
+        3.times{|i|@queue << i}
+        3.times{|i|assert(i, @queue.pop)}
+        assert(@queue.empty?)
+    end
+    def test_pause
+        3.times{|i|@queue << i}
+        @queue.pause
+        output = []
+        3.times{Thread.new{output << @queue.pop}}
+        assert(output.empty?)
+        assert_equal(3, @queue.size)
+        @queue.unpause
+        sleep(1)
+        assert(@queue.empty?)
+        assert_equal(3, output.size)
+        3.times{|i|assert(output.include?(i))}
+        @queue << 1
+        output = nil
+        Thread.new{@queue.wait_empty; output = true}
+        assert_nil(output)
+        @queue.pop
+        Thread.pass
+        sleep(0.01)
+        assert(output)
+    end
+end

data/tests/cases/resize.rb

@@ -0,0 +1,29 @@
+require 'actionpool'
+require 'test/unit'
+
+class ResizePoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def test_resize
+        stop = false
+        20.times{ @pool << lambda{ a = 0; a += 1 until stop || a > 9999999999 } }
+        assert(@pool.size > 10)
+        stop = true
+        @pool.shutdown(true)
+        @pool.max = 10
+        assert_equal(10, @pool.max)
+        assert_equal(0, @pool.size)
+        stop = false
+        20.times{ @pool << lambda{ a = 0; a += 1 until stop || a > 9999999999 } }
+        assert_equal(10, @pool.size)
+        stop = true
+        @pool.shutdown(true)
+        @pool.max = 20
+        stop = false
+        30.times{ @pool << lambda{ a = 0; a += 1 until stop || a > 9999999999 } }
+        stop = true
+        assert(@pool.size > 10)
+        @pool.shutdown(true)
+    end
+end

data/tests/cases/shutdown.rb

@@ -0,0 +1,16 @@
+require 'actionpool'
+require 'test/unit'
+
+class ShutdownPoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def test_shutdown
+        assert_equal(10, @pool.size)
+        @pool.shutdown
+        sleep(0.5)
+        assert_equal(0, @pool.size)
+        @pool << lambda{}
+        assert_equal(10, @pool.size)
+    end
+end

data/tests/cases/thread.rb

@@ -0,0 +1,24 @@
+require 'actionpool'
+require 'test/unit'
+
+class ThreadTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new(:min_threads => 1, :max_threads => 1)
+        @thread = ActionPool::Thread.new(:pool => @pool, :respond_thread => self, :t_timeout => 60, :a_timeout => 0)
+    end
+    def test_thread
+        sleep(0.01)
+        assert(@thread.waiting?)
+        assert_equal(60, @thread.thread_timeout)
+        assert_equal(0, @thread.action_timeout)
+        assert(@thread.alive?)
+        stop = false
+        10.times{ @pool << lambda{ a = 0; a += 1 until stop || a > 9999999999 } }
+        assert(!@thread.waiting?)
+        @thread.stop(:force)
+        sleep(0.01)
+        assert(!@thread.alive?)
+        stop = true
+        @pool.shutdown(true)
+    end
+end

data/tests/cases/timeouts.rb

@@ -0,0 +1,19 @@
+require 'actionpool'
+require 'test/unit'
+
+class TimeoutPoolTest < Test::Unit::TestCase
+    def setup
+        @pool = ActionPool::Pool.new
+    end
+    def test_threadtimeout
+        @pool.thread_timeout = 0.01
+        assert_equal(10, @pool.size)
+        stop = false
+        20.times{ @pool << lambda{ a = 0; a += 1 until stop || a > 9999999999 } }
+        assert(@pool.size > 10)
+        stop = true
+        sleep(2)
+        assert(@pool.size <= 10)
+        @pool.shutdown(true)
+    end
+end

data/tests/run_tests.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+require 'actionpool'
+
+Dir.new("#{File.dirname(__FILE__)}/cases").each{|f|
+    require "#{File.dirname(__FILE__)}/cases/#{f}" if f[-2..f.size] == 'rb'
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ActionPool
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - spox
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-13 00:00:00 -07:00
+date: 2009-10-19 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -21,20 +21,32 @@ extensions: []
 
 extra_rdoc_files: 
 - README.rdoc
+- CHANGELOG
 files: 
-- ActionPool-0.0.1.gem
-- README.rdoc
 - lib
 - lib/actionpool
 - lib/actionpool/LogHelper.rb
-- lib/actionpool/Thread.rb
 - lib/actionpool/Pool.rb
+- lib/actionpool/Thread.rb
 - lib/actionpool/Queue.rb
 - lib/actionpool.rb
+- ActionPool-0.2.0.gem
+- tests
+- tests/cases
+- tests/cases/shutdown.rb
+- tests/cases/nogrow.rb
+- tests/cases/general.rb
+- tests/cases/thread.rb
+- tests/cases/grow.rb
+- tests/cases/timeouts.rb
+- tests/cases/resize.rb
+- tests/cases/queue.rb
+- tests/run_tests.rb
+- CHANGELOG
 - ActionPool-0.1.0.gem
 - LICENSE
-- test2.rb
-- test.rb
+- README.rdoc
+- ActionPool-0.0.1.gem
 - actionpool.gemspec
 has_rdoc: false
 homepage: http://github.com/spox/actionpool

data/test.rb

@@ -1,10 +0,0 @@
-require 'actionpool'
-
-pool = ActionPool::Pool.new
-a = 0
-lock = Mutex.new
-tasks = [].fill(lambda{ lock.synchronize{ a += 1} }, 0..19)
-puts "Size: #{tasks.size}"
-pool.add_jobs(tasks)
-sleep(0.5)
-puts "Result: #{a}"

data/test2.rb

@@ -1,18 +0,0 @@
-    require 'actionpool'
-
-    pool = ActionPool::Pool.new(:min_threads => 1, :max_threads => 3)
-    pool.process do
-        sleep(10)
-        raise 'Wakeup main thread'
-    end
-    20.times do
-        pool.process do
-            puts "Thread: #{Thread.current}"
-            sleep(rand(0.0))
-        end
-    end
-    begin
-        sleep
-    rescue Exception => e
-        puts "Thread pool woke me up: #{e}"
-    end