thread_storm 0.4.0 → 0.5.0

data/CHANGELOG

@@ -1,3 +1,8 @@
+0.5.0
+ - Refactored to use Monitor.
+ - Implemented ThreadStorm#clear_executions.
+ - Implemented the :execute_blocks option.
+ 
 0.4.0
  - Renamed to thread_storm... ugh.
  - Simplified the shutdown process by using my own thread safe queue.

data/README.rdoc

@@ -11,22 +11,22 @@ Simple thread pool with a few advanced features.
 
 == 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"]
+  storm = ThreadStorm.new :size => 2
+  storm.execute{ sleep(0.01); "a" }
+  storm.execute{ sleep(0.01); "b" }
+  storm.execute{ sleep(0.01); "c" }
+  storm.join # Should return in about 0.02 seconds... ;)
+  storm.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
+  storm = ThreadStorm.new :size => 2
+  execution = storm.execute{ sleep(0.01); "a" }
+  storm.execute{ sleep(0.01); "b" }
+  storm.execute{ sleep(0.01); "c" }
+  storm.join
   execution.started?   # true
   execution.finished?  # true
   execution.timed_out? # false
@@ -37,24 +37,24 @@ You can query the state of an execution.
 
 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"
+  storm = ThreadStorm.new :size => 2, :timeout => 0.02, :default_value => "failed"
+  storm.execute{ sleep(0.01); "a" }
+  storm.execute{ sleep(0.03); "b" }
+  storm.execute{ sleep(0.01); "c" }
+  storm.join
+  storm.executions[1].started?   # true
+  storm.executions[1].finished?  # true
+  storm.executions[1].timed_out? # true
+  storm.executions[1].duration   # ~0.02
+  storm.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
+  storm = ThreadStorm.new :size => 2, :reraise => false, :default_value => "failure"
+  execution = storm.execute{ raise("busted"); "a" }
+  storm.join
   execution.value # "failure"
   execution.exception # RuntimeError: busted
 
@@ -64,27 +64,27 @@ ThreadStorm#join blocks until all pending executions are done running.  It does
 
 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" }
+  storm = ThreadStorm.new do |s|
+    s.execute{ "a" }
+    s.execute{ "b" }
+    s.execute{ "c" }
   end
   # At this point, #join and #shutdown have been called.
-  party.values # ["a", "b", "c"]
+  storm.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
+ storm = 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) }
+  storm = ThreadStorm.new :timeout_method => Proc.new{ |seconds, &block| SystemTimer.timeout(seconds, &block) }
     ...
   end
 

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/lib/thread_storm/active_support.rb

@@ -1,5 +1,22 @@
 # Things I miss from active_support.
 
+class Array #:nodoc:
+  
+  def separate
+    selected = []
+    rejected = []
+    each do |item|
+      if yield(item)
+        selected << item
+      else
+        rejected << item
+      end
+    end
+    [selected, rejected]
+  end unless method_defined?(:separate)
+  
+end
+
 class Hash #:nodoc:
   
   def symbolize_keys

data/lib/thread_storm/execution.rb

@@ -1,20 +1,22 @@
+require "monitor"
+
 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:
+    def initialize(args, default_value, &block) #:nodoc:
       @args = args
+      @value = default_value
       @block = block
       @start_time = nil
       @finish_time = nil
-      @value = nil
       @exception = nil
       @timed_out = false
       @thread = nil
-      @mutex = Mutex.new
-      @join = ConditionVariable.new
+      @lock = Monitor.new
+      @cond = @lock.new_cond
     end
     
     def start! #:nodoc:
@@ -33,9 +35,9 @@ class ThreadStorm
     end
     
     def finish! #:nodoc:
-      @mutex.synchronize do
+      @lock.synchronize do
         @finish_time = Time.now
-        @join.signal
+        @cond.signal
       end
     end
     
@@ -70,8 +72,8 @@ class ThreadStorm
     
     # Block until this execution has finished running. 
     def join
-      @mutex.synchronize do
-        @join.wait(@mutex) unless finished?
+      @lock.synchronize do
+        @cond.wait_until{ finished? }
       end
     end
     

data/lib/thread_storm/sentinel.rb

@@ -0,0 +1,18 @@
+require "monitor"
+
+class ThreadStorm
+  class Sentinel
+    attr_reader :e_cond, :p_cond
+    
+    def initialize
+      @lock = Monitor.new
+      @e_cond = @lock.new_cond # execute condition
+      @p_cond = @lock.new_cond # pop condition
+    end
+    
+    def synchronize
+      @lock.synchronize{ yield(@e_cond, @p_cond) }
+    end
+    
+  end
+end

data/lib/thread_storm/worker.rb

@@ -1,12 +1,14 @@
 class ThreadStorm
   class Worker #:nodoc:
-    attr_reader :thread
+    attr_reader :thread, :execution
     
     # 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 }
+    def initialize(queue, sentinel, options)
+      @queue     = queue
+      @sentinel  = sentinel
+      @options   = options
+      @execution = nil # Current execution we're working on.
+      @thread    = Thread.new(self){ |me| me.run }
     end
     
     def timeout
@@ -24,17 +26,29 @@ class ThreadStorm
     
     # 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)
+      @sentinel.synchronize do |e_cond, p_cond|
+        # Become idle and signal that we're idle.
+        @execution = nil
+        e_cond.signal
+        
+        # Give up the lock and wait until there is work to do.
+        p_cond.wait_while{ @queue.empty? }
+        
+        # Get the work to do (implicitly becoming busy).
+        @execution = @queue.pop
+      end
+      
+      process_execution_with_timeout unless die?
     end
     
     # Process the execution, handling timeouts and exceptions.
-    def process_execution_with_timeout(execution)
+    def process_execution_with_timeout
       execution.start!
       begin
         if timeout
-          timeout_method.call(timeout){ process_execution(execution) }
+          timeout_method.call(timeout){ process_execution }
         else
-          process_execution(execution)
+          process_execution
         end
       rescue Timeout::Error => e
         execution.timed_out!
@@ -46,18 +60,17 @@ class ThreadStorm
     end
     
     # Seriously, process the execution.
-    def process_execution(execution)
+    def process_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
+    def busy?
+      !!@execution and not die?
     end
     
     # True if this worker's thread should die.
     def die?
-      !!@die
+      @execution == :die
     end
     
   end

data/lib/thread_storm.rb

@@ -1,13 +1,13 @@
 require "thread"
 require "timeout"
 require "thread_storm/active_support"
-require "thread_storm/queue"
+require "thread_storm/sentinel"
 require "thread_storm/execution"
 require "thread_storm/worker"
 
 class ThreadStorm
   
-  # Array of executions in order as defined by calls to ThreadStorm#execute.
+  # Array of executions in order as they are defined by calls to ThreadStorm#execute.
   attr_reader :executions
   
   # Valid options are
@@ -16,16 +16,18 @@ class ThreadStorm
   #   :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.
+  #   :execute_blocks => True if you want #execute to block until there is an available thread.  Default is false.
   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.
+                                    :reraise => true,
+                                    :execute_blocks => false
+    @sentinel = Sentinel.new
+    @queue = []
     @executions = []
-    @workers = (1..@options[:size]).collect{ Worker.new(@queue, @options) }
-    @start_time = Time.now
+    @workers = (1..@options[:size]).collect{ Worker.new(@queue, @sentinel, @options) }
     if block_given?
       yield(self)
       join
@@ -33,25 +35,20 @@ class ThreadStorm
     end
   end
   
-  def size
+  def size #:nodoc:
     @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.
+  # Creates an 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)
+    Execution.new(args, default_value, &block).tap do |execution|
+      @sentinel.synchronize do |e_cond, p_cond|
+        e_cond.wait_while{ all_workers_busy? } if execute_blocks?
+        @queue << execution
+        @executions << execution
+        p_cond.signal
+      end
     end
   end
   
@@ -66,22 +63,65 @@ class ThreadStorm
   
   # Calls ThreadStorm#join, then collects the values of each execution.
   def values
-    join
-    @executions.collect{ |execution| execution.value }
+    join and @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!
+    @sentinel.synchronize do |e_cond, p_cond|
+      @queue.replace([:die] * size)
+      p_cond.broadcast
+    end
     @workers.each{ |worker| worker.thread.join }
     true
   end
   
-  # Returns an array of threads in the pool.
+  # Returns workers that are currently running executions.
+  def busy_workers
+    @workers.select{ |worker| worker.busy? }
+  end
+  
+  # Returns an array of Ruby threads in the pool.
   def threads
     @workers.collect{ |worker| worker.thread }
   end
   
+  # Removes executions stored at ThreadStorm#executions.  You can selectively remove
+  # them by passing in a block or a symbol.  The following two lines are equivalent.
+  #   storm.clear_executions(:finished?)
+  #   storm.clear_executions{ |e| e.finished? }
+  # Because of the nature of threading, the following code could happen:
+  #   storm.clear_executions(:finished?)
+  #   storm.executions.any?{ |e| e.finished? }
+  # Some executions could have finished between the two calls.
+  def clear_executions(method_name = nil, &block)
+    cleared, @executions = @executions.separate do |execution|
+      if block_given?
+        yield(execution)
+      else
+        execution.send(method_name)
+      end
+    end
+    cleared
+  end
+  
+private
+  
+  def default_value #:nodoc:
+    @options[:default_value]
+  end
+  
+  def reraise? #:nodoc:
+    @options[:reraise]
+  end
+  
+  def execute_blocks? #:nodoc:
+    @options[:execute_blocks]
+  end
+  
+  def all_workers_busy? #:nodoc:
+    @workers.all?{ |worker| worker.busy? }
+  end
+  
 end

data/test/test_thread_storm.rb

@@ -3,40 +3,40 @@ 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)
+    storm = ThreadStorm.new :size => 1
+    storm.execute{ sleep(0.01); "one" }
+    storm.execute{ sleep(0.01); "two" }
+    storm.execute{ sleep(0.01); "three" }
+    assert_equal %w[one two three], storm.values
+    assert_all_threads_worked(storm)
   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)
+    storm = ThreadStorm.new :size => 2
+    storm.execute{ sleep(0.01); "one" }
+    storm.execute{ sleep(0.01); "two" }
+    storm.execute{ sleep(0.01); "three" }
+    assert_equal %w[one two three], storm.values
+    assert_all_threads_worked(storm)
   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)
+    storm = ThreadStorm.new :size => 3
+    storm.execute{ sleep(0.01); "one" }
+    storm.execute{ sleep(0.01); "two" }
+    storm.execute{ sleep(0.01); "three" }
+    assert_equal %w[one two three], storm.values
+    assert_all_threads_worked(storm)
   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)
+    storm = ThreadStorm.new :size => 1, :timeout => 0.015
+    storm.execute{ sleep(0.01); "one" }
+    storm.execute{ sleep(0.02); "two" }
+    storm.execute{ sleep(0.01); "three" }
+    assert_equal ["one", nil, "three"], storm.values
+    assert storm.executions[1].timed_out?
+    assert_all_threads_worked(storm)
   end
   
   # Tricky...
@@ -44,73 +44,119 @@ class TestThreadStorm < Test::Unit::TestCase
   # 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)
+    storm = ThreadStorm.new :size => 2, :timeout => 0.015
+    storm.execute{ sleep(0.01); "one" }
+    storm.execute{ sleep(0.02); "two" }
+    storm.execute{ sleep(0.01); "three" }
+    assert_equal ["one", nil, "three"], storm.values
+    assert storm.executions[1].timed_out?
+    assert_all_threads_worked(storm)
   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)
+    storm = ThreadStorm.new :size => 3, :timeout => 0.015
+    storm.execute{ sleep(0.01); "one" }
+    storm.execute{ sleep(0.02); "two" }
+    storm.execute{ sleep(0.01); "three" }
+    assert_equal ["one", nil, "three"], storm.values
+    assert storm.executions[1].timed_out?
+    assert_all_threads_worked(storm)
   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)
+    storm = ThreadStorm.new :size => 1, :timeout => 0.015, :default_value => "timed out"
+    storm.execute{ sleep(0.01); "one" }
+    storm.execute{ sleep(0.02); "two" }
+    storm.execute{ sleep(0.01); "three" }
+    assert_equal ["one", "timed out", "three"], storm.values
+    assert storm.executions[1].timed_out?
+    assert_all_threads_worked(storm)
   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
+    storm = ThreadStorm.new :size => 3
+    storm.execute{ sleep(0.01); "one" }
+    storm.execute{ sleep(0.01); "two" }
+    storm.execute{ sleep(0.01); "three" }
+    storm.join
     
     assert_equal original_thread_count + 3, Thread.list.length
-    pool.shutdown
+    storm.shutdown
     assert_equal original_thread_count, Thread.list.length
   end
   
   def test_shutdown_before_pop
-    pool = ThreadStorm.new :size => 3
-    pool.shutdown
+    storm = ThreadStorm.new :size => 3
+    storm.shutdown
   end
   
   def test_args
-    pool = ThreadStorm.new :size => 2
+    storm = ThreadStorm.new :size => 2
     %w[one two three four five].each do |word|
-      pool.execute(word){ |w| sleep(0.01); w }
+      storm.execute(word){ |w| sleep(0.01); w }
     end
-    pool.join
-    assert_equal %w[one two three four five], pool.values
+    storm.join
+    assert_equal %w[one two three four five], storm.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" }
+    storm = ThreadStorm.new :size => 1 do |storm|
+      storm.execute{ sleep(0.01); "one" }
+      storm.execute{ sleep(0.01); "two" }
+      storm.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)
+    assert_equal %w[one two three], storm.values
+    assert_all_threads_worked(storm)
+  end
+  
+  def test_execute_blocks
+    t1 = Thread.new do
+      storm = ThreadStorm.new :size => 1, :execute_blocks => true
+      storm.execute{ sleep }
+      storm.execute{ nil }
+    end
+    t2 = Thread.new do
+      storm = ThreadStorm.new :size => 1, :execute_blocks => false
+      storm.execute{ sleep }
+      storm.execute{ nil }
+    end
+    sleep(0.1) # How else??
+    assert_equal "sleep", t1.status
+    assert_equal false, t2.status
+  end
+  
+  def test_clear_executions
+    storm = ThreadStorm.new :size => 3
+    storm.execute{ sleep }
+    storm.execute{ sleep(0.1) }
+    storm.execute{ sleep(0.1) }
+    sleep(0.2) # Ugh another test based on sleeping.
+    finished = storm.clear_executions(:finished?)
+    assert_equal 2, finished.length
+    assert_equal 1, storm.executions.length
+  end
+  
+  def test_execution_blocks_again
+    storm = ThreadStorm.new :size => 10, :execute_blocks => true
+    20.times{ storm.execute{ sleep(rand) } }
+    storm.join
+    storm.shutdown
+  end
+  
+  def test_for_deadlocks
+    ThreadStorm.new :size => 10, :execute_blocks => true do |storm|
+      20.times do
+        storm.execute do
+          ThreadStorm.new :size => 10, :timeout => 0.5 do |storm2|
+            20.times{ storm2.execute{ sleep(rand) } }
+          end
+        end
+      end
+    end
   end
   
 end

data/thread_storm.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{thread_storm}
-  s.version = "0.4.0"
+  s.version = "0.5.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.date = %q{2010-06-21}
   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 = [
@@ -27,7 +27,7 @@ Gem::Specification.new do |s|
      "lib/thread_storm.rb",
      "lib/thread_storm/active_support.rb",
      "lib/thread_storm/execution.rb",
-     "lib/thread_storm/queue.rb",
+     "lib/thread_storm/sentinel.rb",
      "lib/thread_storm/worker.rb",
      "test/helper.rb",
      "test/test_thread_storm.rb",

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: thread_storm
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: false
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Christopher J. Bottaro
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-07 00:00:00 -05:00
+date: 2010-06-21 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -39,7 +39,7 @@ files:
 - lib/thread_storm.rb
 - lib/thread_storm/active_support.rb
 - lib/thread_storm/execution.rb
-- lib/thread_storm/queue.rb
+- lib/thread_storm/sentinel.rb
 - lib/thread_storm/worker.rb
 - test/helper.rb
 - test/test_thread_storm.rb

data/lib/thread_storm/queue.rb

@@ -1,45 +0,0 @@
-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