threadlimiter 0.1.2 → 0.2.0

data/CHANGELOG

@@ -1,3 +1,21 @@
+0.2.0 (11-02-2012)
+
+* Block by default.
+
+* Added option noblock.
+
+* Added ThreadLimiter.open.
+
+* Added ThreadLimiter#wait.
+
+* Removed default limit.
+
+* Removed default number_of_clusters.
+
+* Fixed limit=-1 when calling several methods.
+
+* Worked around a Ruby bug in Thread.fork(*args, &block).
+
 0.1.2 (06-10-2008)
 
 * Introduced ThreadLimiter.handle_clusters, which is reused by

data/README

@@ -13,7 +13,7 @@ The traditional way, using Thread directly:
   titles =
   urls.collect do |url|
     Thread.fork do
-      # ... get the title of the url...
+      # ...get the title of the url...
     end
   end.collect do |thread|
     thread.value
@@ -21,13 +21,15 @@ The traditional way, using Thread directly:
 
 With ThreadLimiter#fork():
 
-  thread_limiter = ThreadLimiter.new(10)   # Max. 10 concurrently running threads.
+  require "threadlimiter"
+
   urls           = [.....]                 # A lot of URL's. Maybe even thousends.
+  thread_limiter = ThreadLimiter.new(10)   # Max. 10 concurrently running threads.
 
   titles =
   urls.collect do |url|
     thread_limiter.fork do
-      # ... get the title of the url...
+      # ...get the title of the url...
     end
   end.collect do |thread|
     thread.value
@@ -35,9 +37,11 @@ With ThreadLimiter#fork():
 
 With Enumerable#threaded_collect():
 
+  require "threadlimiter"
+
   urls           = [.....]                 # A lot of URL's. Maybe even thousends.
 
   titles =
   urls.threaded_collect(10) do |url|       # Max. 10 concurrently running threads.
-    # ... get the title of the url...
+    # ...get the title of the url...
   end

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/lib/threadlimiter/enumerable.rb

@@ -24,7 +24,7 @@ module Enumerable
   # Each cluster is run concurrently in a thread, using ThreadLimiter.new(<i>number_of_clusters</i>) and its fork().
   # Set <i>number_of_clusters</i> to -1 to skip clustering.
 
-  def clustered_threaded_collect(number_of_clusters=-1, &block)
+  def clustered_threaded_collect(number_of_clusters, &block)
     if number_of_clusters <= 0
       threaded_collect(number_of_clusters, &block)
     else
@@ -39,7 +39,7 @@ module Enumerable
     if limit == 0
       self.select(&block)
     else
-      self.zip(self.threaded_collect(limit=-1, &block)).inject([]){|r, (o, b)| r << o if b ; r}
+      self.zip(self.threaded_collect(limit, &block)).inject([]){|r, (o, b)| r << o if b ; r}
     end
   end
 
@@ -50,7 +50,7 @@ module Enumerable
     if limit == 0
       self.reject(&block)
     else
-      self.zip(self.threaded_collect(limit=-1, &block)).inject([]){|r, (o, b)| r << o unless b ; r}
+      self.zip(self.threaded_collect(limit, &block)).inject([]){|r, (o, b)| r << o unless b ; r}
     end
   end
 
@@ -61,7 +61,7 @@ module Enumerable
     if limit == 0
       self.each(&block)
     else
-      threaded_collect(limit=-1, &block)
+      threaded_collect(limit, &block)
 
       self
     end
@@ -71,24 +71,24 @@ module Enumerable
   # Each cluster is run concurrently in a thread, using ThreadLimiter.new(<i>number_of_clusters</i>) and its fork().
   # Set <i>number_of_clusters</i> to -1 to skip clustering.
 
-  def clustered_threaded_select(number_of_clusters=-1, &block)
-    self.zip(self.clustered_threaded_collect(number_of_clusters=-1, &block)).inject([]){|r, (o, b)| r << o if b ; r}
+  def clustered_threaded_select(number_of_clusters, &block)
+    self.zip(self.clustered_threaded_collect(number_of_clusters, &block)).inject([]){|r, (o, b)| r << o if b ; r}
   end
 
   # Like Enumerable#reject(), but all blocks are clustered.
   # Each cluster is run concurrently in a thread, using ThreadLimiter.new(<i>number_of_clusters</i>) and its fork().
   # Set <i>number_of_clusters</i> to -1 to skip clustering.
 
-  def clustered_threaded_reject(number_of_clusters=-1, &block)
-    self.zip(self.clustered_threaded_collect(number_of_clusters=-1, &block)).inject([]){|r, (o, b)| r << o unless b ; r}
+  def clustered_threaded_reject(number_of_clusters, &block)
+    self.zip(self.clustered_threaded_collect(number_of_clusters, &block)).inject([]){|r, (o, b)| r << o unless b ; r}
   end
 
   # Like Enumerable#each(), but all blocks are clustered.
   # Each cluster is run concurrently in a thread, using ThreadLimiter.new(<i>number_of_clusters</i>) and its fork().
   # Set <i>number_of_clusters</i> to -1 to skip clustering.
 
-  def clustered_threaded_each(number_of_clusters=-1, &block)
-    clustered_threaded_collect(number_of_clusters=-1, &block)
+  def clustered_threaded_each(number_of_clusters, &block)
+    clustered_threaded_collect(number_of_clusters, &block)
 
     self
   end

data/lib/threadlimiter/threadlimiter.rb

@@ -4,13 +4,27 @@
 # ThreadLimiter isn't a thread pool. Each fork really starts a new thread.
 
 class ThreadLimiter
+  # Create and use a new ThreadLimiter and wait for all threads to finish.
+
+  def self.open(*args)
+    thread_limiter	= new(*args)
+
+    begin
+      yield(thread_limiter)
+    ensure
+      thread_limiter.wait
+    end
+  end
+
   # Initialize the ThreadLimiter.
   # The optional parameter <i>limit</i> is the maximum number of concurrently running threads.
   # Set <i>limit</i> to -1 or 0 to fork threads without limiting the number of concurrently running threads.
+  # Set options[:noblock] to true to start the new thread before waiting for resources.
 
-  def initialize(limit=-1)
+  def initialize(limit, options={})
     @limit	= limit	# The maximum number of concurrently running threads.
     @running	= 0	# The number of currently running threads.
+    @noblock	= options[:noblock]
 
     @mutex	= Mutex.new
     @cv		= ConditionVariable.new
@@ -24,36 +38,28 @@ class ThreadLimiter
 
   def fork(*args, &block)
     if @limit <= 0
-      Thread.fork(*args, &block)
-    else
-      @mutex.synchronize do
-        while @running >= @limit
-          @cv.wait(@mutex)
-        end
-
-        @running	+= 1
+      Thread.fork do
+        yield(*args)
       end
+    else
+      cv_wait	unless @noblock
 
       Thread.fork do
+        cv_wait	if @noblock
+
         begin
-          res	= yield(*args)
+          yield(*args)
         ensure
-          @mutex.synchronize do
-            @running	-= 1
-          end
-
-          @cv.signal	if @limit > 0
+          cv_signal
         end
-
-        res
       end
     end
   end
 
-  def self.handle_clusters(enumeration, number_of_clusters, method_name, &block)
+  def self.handle_clusters(enumeration, number_of_clusters, method_name, &block)	# :nodoc:
     clusters	= []	# One cluster per fork.
     last_pos	= -1
-    res	= []
+    res		= []
 
     enumeration.each do |object|
       last_pos += 1
@@ -78,4 +84,39 @@ class ThreadLimiter
     res[0..last_pos]	# Remove padding nil.
   end
 
+  # Wait for all threads to finish.
+
+  def wait
+    @mutex.synchronize do
+      while @running > 0
+        @cv.wait(@mutex)
+      end
+    end
+
+    self
+  end
+
+  private
+
+  def cv_wait
+    @mutex.synchronize do
+      while @running >= @limit
+        @cv.wait(@mutex)
+      end
+
+      @running += 1
+    end
+
+    self
+  end
+
+  def cv_signal
+    @mutex.synchronize do
+      @running -= 1
+
+      @cv.signal
+    end
+
+    self
+  end
 end

data/lib/threadlimiter/version.rb

@@ -0,0 +1,3 @@
+class ThreadLimiter
+  VERSION	= "0.2.0"
+end

data/lib/threadlimiter.rb

@@ -1,4 +1,5 @@
 require "thread"
 
+require "threadlimiter/version"
 require "threadlimiter/threadlimiter"
 require "threadlimiter/enumerable"

data/test/test.rb

@@ -2,9 +2,9 @@ require "test/unit"
 require "threadlimiter"
 
 class ThreadLimiterTest < Test::Unit::TestCase
-  def go(limit)
+  def go(limit, options={})
     input		= (1..100).collect{rand}
-    threadlimiter	= ThreadLimiter.new(limit)
+    threadlimiter	= ThreadLimiter.new(limit, options)
 
     threads =
     input.collect do |m|
@@ -17,7 +17,6 @@ class ThreadLimiterTest < Test::Unit::TestCase
 
     assert_equal([Thread], threads.collect{|t| t.class}.uniq)
 
-
     assert_equal(input.to_a	, threads.collect{|t| t.value})
     assert_equal(0		, threadlimiter.instance_eval{@running})
     assert_equal(limit		, threadlimiter.instance_eval{@limit})
@@ -34,6 +33,18 @@ class ThreadLimiterTest < Test::Unit::TestCase
   def test_with_zero_limit
     go(0)
   end
+
+  def test_with_limit_with_noblock
+    go(10, :noblock=>true)
+  end
+
+  def test_with_no_limit_with_noblock
+    go(-1, :noblock=>true)
+  end
+
+  def test_with_zero_limit_with_noblock
+    go(0, :noblock=>true)
+  end
 end
 
 class ThreadLimiterEnumerableTest < Test::Unit::TestCase

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: threadlimiter
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Erik Veenstra
@@ -9,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-06 00:00:00 +02:00
-default_executable: 
+date: 2012-02-11 00:00:00 Z
 dependencies: []
 
 description: Fork threads like Thread.fork, but limit the number of concurrently running threads.
@@ -22,16 +27,18 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/threadlimiter
-- lib/threadlimiter/threadlimiter.rb
-- lib/threadlimiter/enumerable.rb
 - lib/threadlimiter.rb
+- lib/threadlimiter/enumerable.rb
+- lib/threadlimiter/threadlimiter.rb
+- lib/threadlimiter/version.rb
 - README
 - LICENSE
 - VERSION
 - CHANGELOG
-has_rdoc: true
+- test/test.rb
 homepage: http://www.erikveen.dds.nl/threadlimiter/index.html
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - README
@@ -39,29 +46,35 @@ rdoc_options:
 - VERSION
 - CHANGELOG
 - --title
-- threadlimiter (0.1.2)
+- threadlimiter (0.2.0)
 - --main
 - README
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: threadlimiter
-rubygems_version: 1.2.0
+rubygems_version: 1.8.12
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Fork threads like Thread.fork, but limit the number of concurrently running threads.
 test_files: 
 - test/test.rb