ruby_thread_pool 0.1.0

data/lib/thread_pool.rb

@@ -0,0 +1,59 @@
+require "thread"
+
+class ThreadPool
+  def initialize(pool_size)
+    @pool = []
+    @pool_size = pool_size
+    @pool_mutex = Mutex.new
+    @pool_cv = ConditionVariable.new
+  end
+
+  def run(*args)
+    Thread.new do
+      @pool_mutex.synchronize do
+        while @pool.size >= @pool_size
+          print "Pool is full: waiting to run #{args.join(",")}\n" if $DEBUG
+          @pool_cv.wait(@pool_mutex)
+        end
+      end
+      @pool << Thread.current
+      begin
+        yield(*args)
+      rescue => e
+        on_exception(self, e, *args)
+      ensure
+        @pool_mutex.synchronize do
+          @pool.delete(Thread.current)
+          @pool_cv.signal
+        end
+      end
+    end
+  end
+
+  alias_method :new, :run
+
+  def join
+    sleep 0.001 # needed because join must be called after threads
+                # had chance to lock
+    @pool_mutex.synchronize { @pool_cv.wait(@pool_mutex) until @pool.empty? }
+  end
+
+  def on_exception(thread, exception, *original_args)
+    # if you want to handle exception subclass and implement this method
+  end
+end
+
+class Array
+  def peach(size=nil, type=ThreadPool, &block)
+    if size == nil
+      threads = []
+      each { |*args| threads << Thread.new(*args, &block) }
+      threads.each {|t| t.join }
+      self
+    else
+      pool = type.new(size)
+      each { |*args| pool.new(*args, &block) }
+      pool.join
+    end
+  end
+end

data/spec/thread_pool_test.rb

@@ -0,0 +1,34 @@
+require "minitest/autorun"
+require_relative "../lib/thread_pool"
+
+describe "ThreadPool" do
+  it "should wait for threads to finish" do
+    start = Time.now
+    10.times.to_a.peach { sleep 0.1 }
+    stop = Time.now
+    time = stop - start
+    time.must_be :>=, 0.1
+    time.must_be :<=, 0.2
+  end
+
+  it "should run at max so many threads" do
+    start = Time.now
+    20.times.to_a.peach(10) { sleep(0.1) }
+    stop = Time.now
+    time = stop - start
+    time.must_be :>=, 0.2
+    time.must_be :<=, 0.3
+  end
+
+  it "should not stop on long running threads" do
+    a = [0.01,0.01,0.2,0.2, 0.01, 0.01,0.01,0.01,0.01,0.01]
+    start = Time.now
+    a.peach(5) do |time|
+      sleep time
+    end
+    stop = Time.now
+    elapsed = stop - start
+    elapsed.must_be :>=, 0.2
+    elapsed.must_be :<=, 0.3
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: ruby_thread_pool
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jürgen Bickert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-17 00:00:00.000000000 Z
+dependencies: []
+description: You can easily run number limited threads in parallel with ruby.
+email: juergenbickert@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/thread_pool.rb
+- spec/thread_pool_test.rb
+homepage: http://juergenbickert.de
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A thread pool library for ruby.
+test_files:
+- spec/thread_pool_test.rb