thread_storm 0.4.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/CHANGELOG

@@ -0,0 +1,20 @@
+0.4.0
+ - Renamed to thread_storm... ugh.
+ - Simplified the shutdown process by using my own thread safe queue.
+ - Removed timing based tests.
+ - Much more efficient ThreadStorm#join.
+ - Added Execution#join.
+ - Configurable Timeout implementation.
+
+0.3.0
+ - PoolParty#new now takes an optional block.
+ 
+0.2.0
+ - Renamed to pool_party.
+ - Fixed PoolParty#shutdown for real.
+
+0.1.1
+  - Fixed ThreadPool#shutdown.
+
+0.1.0
+ - Initial version

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Christopher J. Bottaro
+
+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/README.rdoc

@@ -0,0 +1,93 @@
+= thread_storm
+
+Simple thread pool with a few advanced features.
+
+== Features
+
+  * execution state querying
+  * timeouts and configurable timeout implementation
+  * graceful error handling
+  * unit tests
+
+== Example
+
+  pool = ThreadStorm.new :size => 2
+  pool.execute{ sleep(0.01); "a" }
+  pool.execute{ sleep(0.01); "b" }
+  pool.execute{ sleep(0.01); "c" }
+  pool.join # Should return in about 0.02 seconds... ;)
+  pool.values # ["a", "b", "c"]
+
+== Execution state
+
+You can query the state of an execution.
+
+  pool = ThreadStorm.new :size => 2
+  execution = pool.execute{ sleep(0.01); "a" }
+  pool.execute{ sleep(0.01); "b" }
+  pool.execute{ sleep(0.01); "c" }
+  pool.join
+  execution.started?   # true
+  execution.finished?  # true
+  execution.timed_out? # false
+  execution.duration   # ~0.01
+  execution.value      # "a"
+
+== Timeouts
+
+You can restrict how long executions are allowed to run for.
+
+  pool = ThreadStorm.new :size => 2, :timeout => 0.02, :default_value => "failed"
+  pool.execute{ sleep(0.01); "a" }
+  pool.execute{ sleep(0.03); "b" }
+  pool.execute{ sleep(0.01); "c" }
+  pool.join
+  pool.executions[1].started?   # true
+  pool.executions[1].finished?  # true
+  pool.executions[1].timed_out? # true
+  pool.executions[1].duration   # ~0.02
+  pool.executions[1].value      # "failed"
+
+== Error handling
+
+If an execution causes an exception, it will be reraised when ThreadStorm#join (or any other method that calls ThreadStorm#join) is called, unless you pass <tt>:reraise => false</tt> to ThreadStorm#new.  The exception is stored in ThreadStorm::Execution#exception.
+
+  pool = ThreadStorm.new :size => 2, :reraise => false, :default_value => "failure"
+  execution = pool.execute{ raise("busted"); "a" }
+  pool.join
+  execution.value # "failure"
+  execution.exception # RuntimeError: busted
+
+== Joining vs shutting down
+
+ThreadStorm#join blocks until all pending executions are done running.  It does not actually kill the thread storm's worker threads (incase you want to do more work).  ThreadStorm#shutdown actually kills the worker threads.
+
+Sometimes it can be a pain to remember to call #shutdown, so as a convenience, you can pass a block to ThreadStorm#new and #join and #shutdown will be called for you.
+
+  party = ThreadStorm.new do |p|
+    p.execute{ "a" }
+    p.execute{ "b" }
+    p.execute{ "c" }
+  end
+  # At this point, #join and #shutdown have been called.
+  party.values # ["a", "b", "c"]
+
+== Configurable timeout method
+
+<tt>Timeout.timeout</tt> is unreliable in MRI 1.8.x.  To address this, you can have ThreadStorm use an alternative implementation.
+
+ require "system_timer"
+ party = ThreadStorm.new :timeout_method => SystemTimer.method(:timeout) do
+   ...
+ end
+ 
+The <tt>:timeout_method</tt> option takes any callable object (i.e. <tt>responds_to?(:call)</tt>) that implements something similar to <tt>Timeout.timeout</tt> (i.e. takes the same arguments and raises <tt>Timeout::Error</tt>).
+
+  require "system_timer"
+  party = ThreadStorm.new :timeout_method => Proc.new{ |seconds, &block| SystemTimer.timeout(seconds, &block) }
+    ...
+  end
+
+== Copyright
+
+Copyright (c) 2010 Christopher J. Bottaro. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "thread_storm"
+    gem.summary = %Q{Simple thread pool with a few advanced features.}
+    gem.description = %Q{Simple thread pool with timeouts, default values, error handling, state tracking and unit tests.}
+    gem.email = "cjbottaro@alumni.cs.utexas.edu"
+    gem.homepage = "http://github.com/cjbottaro/thread_storm"
+    gem.authors = ["Christopher J. Bottaro"]
+    #gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "thread_storm #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/lib/thread_storm/active_support.rb

@@ -0,0 +1,26 @@
+# Things I miss from active_support.
+
+class Hash #:nodoc:
+  
+  def symbolize_keys
+    inject({}){ |memo, (k, v)| memo[k.to_sym] = v; memo }
+  end unless method_defined?(:symbolize_keys)
+  
+  def reverse_merge(other)
+    other.merge(self)
+  end unless method_defined?(:reverse_merge)
+  
+  def option_merge(options)
+    symbolize_keys.reverse_merge(options)
+  end
+  
+end
+
+class Object #:nodoc:
+  
+  def tap
+    yield(self)
+    self
+  end unless method_defined?(:tap)
+  
+end

data/lib/thread_storm/execution.rb

@@ -0,0 +1,89 @@
+class ThreadStorm
+  # Encapsulates a unit of work to be sent to the thread pool.
+  class Execution
+    attr_writer :value, :exception #:nodoc:
+    attr_reader :args, :block, :thread #:nodoc:
+    
+    def initialize(args, &block) #:nodoc:
+      @args = args
+      @block = block
+      @start_time = nil
+      @finish_time = nil
+      @value = nil
+      @exception = nil
+      @timed_out = false
+      @thread = nil
+      @mutex = Mutex.new
+      @join = ConditionVariable.new
+    end
+    
+    def start! #:nodoc:
+      @thread = Thread.current
+      @start_time = Time.now
+    end
+    
+    # True if this execution has started running.
+    def started?
+      !!start_time
+    end
+    
+    # When this execution began to run.
+    def start_time
+      @start_time
+    end
+    
+    def finish! #:nodoc:
+      @mutex.synchronize do
+        @finish_time = Time.now
+        @join.signal
+      end
+    end
+    
+    # True if this execution has finished running.
+    def finished?
+      !!finish_time
+    end
+    
+    # When this execution finished running (either cleanly or with error).
+    def finish_time
+      @finish_time
+    end
+    
+    # How long this this execution ran for (i.e. finish_time - start_time)
+    # or if it hasn't finished, how long it has been running for.
+    def duration
+      if finished?
+        finish_time - start_time
+      else
+        Time.now - start_time
+      end
+    end
+    
+    def timed_out! #:nodoc:
+      @timed_out = true
+    end
+    
+    # True if the execution went over the timeout limit.
+    def timed_out?
+      !!@timed_out
+    end
+    
+    # Block until this execution has finished running. 
+    def join
+      @mutex.synchronize do
+        @join.wait(@mutex) unless finished?
+      end
+    end
+    
+    # If this execution finished with an exception, it is stored here.
+    def exception
+      @exception
+    end
+    
+    # The value returned by the execution's code block.
+    def value
+      @value
+    end
+    
+  end
+end

data/lib/thread_storm/queue.rb

@@ -0,0 +1,45 @@
+require "thread"
+
+class ThreadStorm
+  class Queue #:nodoc:
+    
+    def initialize
+      @lock  = Mutex.new
+      @cond  = ConditionVariable.new
+      @die   = false
+      @queue = []
+    end
+    
+    # Pushes a value on the queue and wakes up the next thread waiting on #pop.
+    def push(value)
+      @lock.synchronize do 
+        @queue.push(value)
+        @cond.signal # Wake up next thread waiting on #pop.
+      end
+    end
+    
+    # Pops a value of the queue.  Blocks if the queue is empty.
+    def pop
+      @lock.synchronize do
+        @cond.wait(@lock) if @queue.empty? and not die?
+        @queue.pop
+      end
+    end
+    
+    # Clears the queue.  Any calls to #pop will immediately return with nil.
+    def die!
+      @lock.synchronize do
+        @die = true
+        @queue.clear
+        @cond.broadcast # Wake up any threads waiting on #pop.
+      end
+    end
+  
+  private
+  
+    def die?
+      !!@die
+    end
+    
+  end
+end

data/lib/thread_storm/worker.rb

@@ -0,0 +1,64 @@
+class ThreadStorm
+  class Worker #:nodoc:
+    attr_reader :thread
+    
+    # Takes the threadsafe queue and options from the thread pool.
+    def initialize(queue, options)
+      @queue   = queue
+      @options = options
+      @thread  = Thread.new(self){ |me| me.run }
+    end
+    
+    def timeout
+      @timeout ||= @options[:timeout]
+    end
+    
+    def timeout_method
+      @timeout_method ||= @options[:timeout_method]
+    end
+    
+    # Pop executions and process them until we're signaled to die.
+    def run
+      pop_and_process_execution while not die?
+    end
+    
+    # Pop an execution off the queue and process it, or pass off control to a different thread.
+    def pop_and_process_execution
+      execution = @queue.pop and process_execution_with_timeout(execution)
+    end
+    
+    # Process the execution, handling timeouts and exceptions.
+    def process_execution_with_timeout(execution)
+      execution.start!
+      begin
+        if timeout
+          timeout_method.call(timeout){ process_execution(execution) }
+        else
+          process_execution(execution)
+        end
+      rescue Timeout::Error => e
+        execution.timed_out!
+      rescue Exception => e
+        execution.exception = e
+      ensure
+        execution.finish!
+      end
+    end
+    
+    # Seriously, process the execution.
+    def process_execution(execution)
+      execution.value = execution.block.call(*execution.args)
+    end
+    
+    # So the thread pool can signal this worker's thread to end.
+    def die!
+      @die = true
+    end
+    
+    # True if this worker's thread should die.
+    def die?
+      !!@die
+    end
+    
+  end
+end

data/lib/thread_storm.rb

@@ -0,0 +1,87 @@
+require "thread"
+require "timeout"
+require "thread_storm/active_support"
+require "thread_storm/queue"
+require "thread_storm/execution"
+require "thread_storm/worker"
+
+class ThreadStorm
+  
+  # Array of executions in order as defined by calls to ThreadStorm#execute.
+  attr_reader :executions
+  
+  # Valid options are
+  #   :size => How many threads to spawn.  Default is 2.
+  #   :timeout => Max time an execution is allowed to run before terminating it.  Default is nil (no timeout).
+  #   :timeout_method => An object that implements something like Timeout.timeout via #call.  Default is Timeout.method(:timeout).
+  #   :default_value => Value of an execution if it times out or errors.  Default is nil.
+  #   :reraise => True if you want exceptions reraised when ThreadStorm#join is called.  Default is true.
+  def initialize(options = {})
+    @options = options.option_merge :size => 2,
+                                    :timeout => nil,
+                                    :timeout_method => Timeout.method(:timeout),
+                                    :default_value => nil,
+                                    :reraise => true
+    @queue = Queue.new # This is threadsafe.
+    @executions = []
+    @workers = (1..@options[:size]).collect{ Worker.new(@queue, @options) }
+    @start_time = Time.now
+    if block_given?
+      yield(self)
+      join
+      shutdown
+    end
+  end
+  
+  def size
+    @options[:size]
+  end
+  
+  def default_value
+    @options[:default_value]
+  end
+  
+  def reraise?
+    @options[:reraise]
+  end
+  
+  # Create and execution and schedules it to be run by the thread pool.
+  # Return value is a ThreadStorm::Execution.
+  def execute(*args, &block)
+    Execution.new(args, &block).tap do |execution|
+      execution.value = default_value
+      @executions << execution
+      @queue.push(execution)
+    end
+  end
+  
+  # Block until all pending executions are finished running.
+  # Reraises any exceptions caused by executions unless <tt>:reraise => false</tt> was passed to ThreadStorm#new.
+  def join
+    @executions.each do |execution|
+      execution.join
+      raise execution.exception if execution.exception and reraise?
+    end
+  end
+  
+  # Calls ThreadStorm#join, then collects the values of each execution.
+  def values
+    join
+    @executions.collect{ |execution| execution.value }
+  end
+  
+  # Signals the worker threads to terminate immediately (ignoring any pending
+  # executions) and blocks until they do.
+  def shutdown
+    @workers.each{ |worker| worker.die! }
+    @queue.die!
+    @workers.each{ |worker| worker.thread.join }
+    true
+  end
+  
+  # Returns an array of threads in the pool.
+  def threads
+    @workers.collect{ |worker| worker.thread }
+  end
+  
+end

data/test/helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'test/unit'
+require "set"
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'thread_storm'
+
+class Test::Unit::TestCase
+  
+  def assert_in_delta(expected, actual, delta)
+    assert (expected - actual).abs < delta, "#{actual} is not within #{delta} of #{expected}"
+  end
+  
+  def assert_all_threads_worked(pool)
+    assert_equal pool.threads.to_set, pool.executions.collect{ |e| e.thread }.to_set
+  end
+  
+end

data/test/test_thread_storm.rb

@@ -0,0 +1,116 @@
+require 'helper'
+
+class TestThreadStorm < Test::Unit::TestCase
+  
+  def test_no_concurrency
+    pool = ThreadStorm.new :size => 1
+    pool.execute{ sleep(0.01); "one" }
+    pool.execute{ sleep(0.01); "two" }
+    pool.execute{ sleep(0.01); "three" }
+    assert_equal %w[one two three], pool.values
+    assert_all_threads_worked(pool)
+  end
+  
+  def test_partial_concurrency
+    pool = ThreadStorm.new :size => 2
+    pool.execute{ sleep(0.01); "one" }
+    pool.execute{ sleep(0.01); "two" }
+    pool.execute{ sleep(0.01); "three" }
+    assert_equal %w[one two three], pool.values
+    assert_all_threads_worked(pool)
+  end
+  
+  def test_full_concurrency
+    pool = ThreadStorm.new :size => 3
+    pool.execute{ sleep(0.01); "one" }
+    pool.execute{ sleep(0.01); "two" }
+    pool.execute{ sleep(0.01); "three" }
+    assert_equal %w[one two three], pool.values
+    assert_all_threads_worked(pool)
+  end
+  
+  def test_timeout_no_concurrency
+    pool = ThreadStorm.new :size => 1, :timeout => 0.015
+    pool.execute{ sleep(0.01); "one" }
+    pool.execute{ sleep(0.02); "two" }
+    pool.execute{ sleep(0.01); "three" }
+    assert_equal ["one", nil, "three"], pool.values
+    assert pool.executions[1].timed_out?
+    assert_all_threads_worked(pool)
+  end
+  
+  # Tricky...
+  # 1 0.01s  ----
+  # 2 0.015s ------
+  # 3 0.01s      ----
+  def test_timeout_partial_concurrency
+    pool = ThreadStorm.new :size => 2, :timeout => 0.015
+    pool.execute{ sleep(0.01); "one" }
+    pool.execute{ sleep(0.02); "two" }
+    pool.execute{ sleep(0.01); "three" }
+    assert_equal ["one", nil, "three"], pool.values
+    assert pool.executions[1].timed_out?
+    assert_all_threads_worked(pool)
+  end
+  
+  def test_timeout_full_concurrency
+    pool = ThreadStorm.new :size => 3, :timeout => 0.015
+    pool.execute{ sleep(0.01); "one" }
+    pool.execute{ sleep(0.02); "two" }
+    pool.execute{ sleep(0.01); "three" }
+    assert_equal ["one", nil, "three"], pool.values
+    assert pool.executions[1].timed_out?
+    assert_all_threads_worked(pool)
+  end
+  
+  def test_timeout_with_default_value
+    pool = ThreadStorm.new :size => 1, :timeout => 0.015, :default_value => "timed out"
+    pool.execute{ sleep(0.01); "one" }
+    pool.execute{ sleep(0.02); "two" }
+    pool.execute{ sleep(0.01); "three" }
+    assert_equal ["one", "timed out", "three"], pool.values
+    assert pool.executions[1].timed_out?
+    assert_all_threads_worked(pool)
+  end
+  
+  def test_shutdown
+    original_thread_count = Thread.list.length
+    
+    pool = ThreadStorm.new :size => 3
+    pool.execute{ sleep(0.01); "one" }
+    pool.execute{ sleep(0.01); "two" }
+    pool.execute{ sleep(0.01); "three" }
+    pool.join
+    
+    assert_equal original_thread_count + 3, Thread.list.length
+    pool.shutdown
+    assert_equal original_thread_count, Thread.list.length
+  end
+  
+  def test_shutdown_before_pop
+    pool = ThreadStorm.new :size => 3
+    pool.shutdown
+  end
+  
+  def test_args
+    pool = ThreadStorm.new :size => 2
+    %w[one two three four five].each do |word|
+      pool.execute(word){ |w| sleep(0.01); w }
+    end
+    pool.join
+    assert_equal %w[one two three four five], pool.values
+  end
+  
+  def test_new_with_block
+    thread_count = Thread.list.length
+    pool = ThreadStorm.new :size => 1 do |party|
+      party.execute{ sleep(0.01); "one" }
+      party.execute{ sleep(0.01); "two" }
+      party.execute{ sleep(0.01); "three" }
+    end
+    assert_equal thread_count, Thread.list.length
+    assert_equal %w[one two three], pool.values
+    assert_all_threads_worked(pool)
+  end
+  
+end

data/thread_storm.gemspec

@@ -0,0 +1,56 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{thread_storm}
+  s.version = "0.4.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Christopher J. Bottaro"]
+  s.date = %q{2010-06-07}
+  s.description = %q{Simple thread pool with timeouts, default values, error handling, state tracking and unit tests.}
+  s.email = %q{cjbottaro@alumni.cs.utexas.edu}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "CHANGELOG",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/thread_storm.rb",
+     "lib/thread_storm/active_support.rb",
+     "lib/thread_storm/execution.rb",
+     "lib/thread_storm/queue.rb",
+     "lib/thread_storm/worker.rb",
+     "test/helper.rb",
+     "test/test_thread_storm.rb",
+     "thread_storm.gemspec"
+  ]
+  s.homepage = %q{http://github.com/cjbottaro/thread_storm}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Simple thread pool with a few advanced features.}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_thread_storm.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: thread_storm
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
+platform: ruby
+authors: 
+- Christopher J. Bottaro
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-07 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Simple thread pool with timeouts, default values, error handling, state tracking and unit tests.
+email: cjbottaro@alumni.cs.utexas.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- CHANGELOG
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/thread_storm.rb
+- lib/thread_storm/active_support.rb
+- lib/thread_storm/execution.rb
+- lib/thread_storm/queue.rb
+- lib/thread_storm/worker.rb
+- test/helper.rb
+- test/test_thread_storm.rb
+- thread_storm.gemspec
+has_rdoc: true
+homepage: http://github.com/cjbottaro/thread_storm
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple thread pool with a few advanced features.
+test_files: 
+- test/helper.rb
+- test/test_thread_storm.rb