fizx-thread_pool 0.2.1 → 0.3.1

data/CHANGELOG

@@ -1,3 +1,7 @@
+0.3.1
+- rescue Thread errors, use Loggable to print backtraces
+0.3.0
+- allow execute to take args, so we can reset the scope
 0.2.1
 - mutex in case Array#<< and Array#shift aren't atomic
 0.2.0

data/README

@@ -1,3 +1,5 @@
+This code is still pretty early, and not yet used in production.  That said, I am interested in feedback.  You can send me a message on GitHub's internal messaging system (http://github.com/inbox/new/fizx).
+
 A simple executor-style ThreadPool for Ruby (with tests, yay!)
 
 Usage:
@@ -6,4 +8,22 @@ Usage:
 	require "thread_pool"
 	pool = ThreadPool.new(threads = 10)
 	pool.execute { puts "I'm writing from a thread" }
+	pool.join
+	
+It's often useful to make sure that the properties of Ruby's blocks don't bite you.  The following code will usually print three nils, because n keeps changing.
+
+	pool = ThreadPool.new(threads = 10)
+	numbers = [1, 2, 3]
+	while n = numbers.shift
+		pool.execute { puts n.inspect }
+	end
+	pool.join
+	
+Passing arguments to execute avoids this. i.e.:
+
+	pool = ThreadPool.new(threads = 10)
+	numbers = [1, 2, 3]
+	while n = numbers.shift
+		pool.execute(n) {|local| puts local.inspect }
+	end
 	pool.join

data/lib/thread_pool.rb

@@ -1,17 +1,30 @@
 # Hooray 
 require "thread"
+require "rubygems"
+require "loggable"
+
 class ThreadPool
+  include Loggable
   class Executor
+    include Loggable
     attr_reader :active
     
     def initialize(queue, mutex)
       @thread = Thread.new do
         loop do
-          mutex.synchronize { @block = queue.shift }
-          if @block
+          mutex.synchronize { @tuple = queue.shift }
+          if @tuple
+            debug "Executor: processing #{@tuple.hash}"
+            args, block = @tuple
             @active = true
-            @block.call
-            @block.complete = true
+            begin
+              block.call(*args)
+            rescue Exception => e
+              error e.message
+              error e.backtrace.join("\n")
+            end
+            block.complete = true
+            debug "Executor: complete   #{@tuple.hash}"
           else
             @active = false
             sleep 0.01
@@ -38,7 +51,7 @@ class ThreadPool
   end
   
   # Runs the block at some time in the near future
-  def execute(&block)
+  def execute(*args, &block)
     init_completable(block)
     
     if @queue_limit > 0
@@ -46,13 +59,13 @@ class ThreadPool
     end
       
     @mutex.synchronize do
-      @queue << block
+      @queue << [args, block]
     end
   end
   
   # Runs the block at some time in the near future, and blocks until complete  
-  def synchronous_execute(&block)
-    execute(&block)
+  def synchronous_execute(*args, &block)
+    execute(*args, &block)
     sleep 0.01 until block.complete?
   end
   

data/test/test_thread_pool.rb

@@ -30,6 +30,31 @@ class TestThreadPool < Test::Unit::TestCase
     assert_equal n - THREADS, @pool.waiting
   end
   
+  class A
+    def initialize(i)
+      @i = i
+    end
+    attr_reader :i
+  end
+  
+  def test_context
+    @foo = []
+    @bar = (0...5).to_a
+    while c = @bar.shift
+      @pool.execute { @foo << c }
+    end
+    @pool.join
+    assert_equal [nil] * 5, @foo
+    
+    @foo = []
+    @bar = (0...5).to_a
+    while c = @bar.shift
+      @pool.execute(c) {|n| @foo << n }
+    end
+    @pool.join
+    assert_equal (0...5).to_a, @foo
+  end
+  
   def test_queue_limit
     n = 50
     @foo = 0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: fizx-thread_pool
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Kyle Maxwell