quack_concurrency 0.4.1 → 0.5.0

data/lib/quack_concurrency/reentrant_mutex.rb

@@ -2,113 +2,138 @@
 
 
 module QuackConcurrency
-  class ReentrantMutex < ConcurrencyTool
+  class ReentrantMutex < Mutex
   
     # Creates a new {ReentrantMutex} concurrency tool.
-    # @param duck_types [Hash] hash of core Ruby classes to overload.
-    #   If a +Hash+ is given, the keys +:condition_variable+ and +:mutex+ must be present.
     # @return [ReentrantMutex]
-    def initialize(duck_types: nil)
-      classes = setup_duck_types(duck_types)
-      @condition_variable = classes[:condition_variable].new
-      @mutex = classes[:mutex].new
-      @owner = nil
+    def initialize
+      super
       @lock_depth = 0
     end
     
-    # Locks this {ReentrantMutex}. Will block until available.
-    # @return [void]
-    def lock
-      @mutex.synchronize do
-        @condition_variable.wait(@mutex) if @owner && @owner != caller
-        raise 'internal error, invalid state' if @owner && @owner != caller 
-        @owner = caller
+    #@overload lock
+    #  Obtains the lock or sleeps the current `Thread` until it is available.
+    #  @return [void]
+    #@overload lock(&block)
+    #  Obtains the lock, runs the block, then releases the lock when the block completes.
+    #  @yield block to run with the lock
+    #  @return [Object] result of the block
+    def lock(&block)
+      if block_given?  
+        lock
+        start_depth = @lock_depth
+        start_owner = owner
+        begin
+          yield
+        ensure
+          unless @lock_depth == start_depth && owner == start_owner
+            raise Error, 'could not unlock reentrant mutex as its state has been modified'
+          end
+          unlock
+        end
+      else
+        super unless owned?
         @lock_depth += 1
+        nil
       end
-      nil
-    end
-    
-    # Checks if this {ReentrantMutex} is locked by some thread.
-    # @return [Boolean]
-    def locked?
-      !!@owner
     end
     
-    # Checks if this {ReentrantMutex} is locked by a thread other than the caller.
+    # Checks if this {ReentrantMutex} is locked by a Thread other than the caller.
     # @return [Boolean]
     def locked_out?
-      @mutex.synchronize { locked? && @owner != caller }
-    end
-    
-    # Checks if this {ReentrantMutex} is locked by the calling thread.
-    # @return [Boolean]
-    def owned?
-      @owner == caller
+      # don't need a mutex because we know #owned? can't change during the call 
+      locked? && !owned?
     end
     
     # Releases the lock and sleeps.
-    # When the calling thread is next woken up, it will attempt to reacquire the lock.
-    # @param timeout [Integer] seconds to sleep, +nil+ will sleep forever
-    # @raise [Error] if this {ReentrantMutex} wasn't locked by the calling thread.
+    # When the calling Thread is next woken up, it will attempt to reacquire the lock.
+    # @param timeout [Integer] seconds to sleep, `nil` will sleep forever
+    # @raise [Error] if this {ReentrantMutex} wasn't locked by the calling Thread
     # @return [void]
     def sleep(timeout = nil)
-      unlock
-      # i would rather not need to get a ducktype for sleep so we will just take
-      #   advantage of Mutex's sleep method that must take it into account already
-      @mutex.synchronize do
-        @mutex.sleep(timeout)
+      raise Error, 'can not unlock reentrant mutex, it is not locked' unless locked?
+      raise Error, 'can not unlock reentrant mutex, caller is not the owner' unless owned?
+      base_depth do
+        super(timeout)
       end
-      nil
-    ensure
-      lock unless owned?
     end
     
     # Obtains a lock, runs the block, and releases the lock when the block completes.
-    # @return return value from yielded block
-    def synchronize
-      lock
-      start_depth = @lock_depth
-      start_owner = @owner
-      result = yield
-      result
-    ensure
-      unless @lock_depth == start_depth && @owner == start_owner
-        raise Error, 'could not unlock reentrant mutex as its state has been modified'
-      end
-      unlock
+    # @return [Object] value from yielded block
+    def synchronize(&block)
+      lock(&block)
     end
     
+    alias parent_try_lock try_lock
+    private :parent_try_lock
     # Attempts to obtain the lock and returns immediately.
     # @return [Boolean] returns if the lock was granted
     def try_lock
-      @mutex.synchronize do
-        return false if @owner && @owner != caller
-        @owner = caller
+      if owned?
         @lock_depth += 1
         true
+      else
+        lock_successful = parent_try_lock
+        if lock_successful
+          @lock_depth += 1
+          true
+        else
+          false
+        end
       end
     end
     
     # Releases the lock.
-    # @raise [Error] if {ReentrantMutex} wasn't locked by the calling thread
+    # @raise [Error] if {ReentrantMutex} wasn't locked by the calling Thread
     # @return [void]
-    def unlock
-      @mutex.synchronize do
-        raise Error, 'can not unlock reentrant mutex, it is not locked' if @lock_depth == 0
-        raise Error, 'can not unlock reentrant mutex, caller is not the owner' unless @owner == caller
+    def unlock(&block)
+      raise Error, 'can not unlock reentrant mutex, it is not locked' unless locked?
+      raise Error, 'can not unlock reentrant mutex, caller is not the owner' unless owned?
+      if block_given?
+        unlock
+        begin
+          yield
+        ensure
+          lock
+        end
+      else
         @lock_depth -= 1
-        if @lock_depth == 0
-          @owner = nil
-          @condition_variable.signal
+        super if @lock_depth == 0
+        nil
+      end
+    end
+    
+    # Releases the lock.
+    # @raise [Error] if {ReentrantMutex} wasn't locked by the calling Thread
+    # @return [void]
+    def unlock!(&block)
+      raise Error, 'can not unlock reentrant mutex, it is not locked' unless locked?
+      raise Error, 'can not unlock reentrant mutex, caller is not the owner' unless owned?
+      if block_given?
+        base_depth do
+          unlock
+          begin
+            yield
+          ensure
+            lock
+          end
         end
+      else
+        @lock_depth = 0
+        super
+        nil
       end
-      nil
     end
     
     private
     
-    def caller
-      Thread.current
+    # @api private
+    def base_depth(&block)
+      start_depth = @lock_depth
+      @lock_depth = 1
+      yield
+    ensure
+      @lock_depth = start_depth
     end
     
   end

data/lib/quack_concurrency/semaphore.rb

@@ -1,21 +1,21 @@
+# not ready yet
+
 module QuackConcurrency
-  class Semaphore < ConcurrencyTool
+  class Semaphore
   
     # Gets total permit count
     # @return [Integer]
     attr_reader :permit_count
     
     # Creates a new {Semaphore} concurrency tool.
-    # @param duck_types [Hash] hash of core Ruby classes to overload.
-    #   If a +Hash+ is given, the keys +:condition_variable+ and +:mutex+ must be present.
     # @return [Semaphore]
-    def initialize(permit_count = 1, duck_types: nil)
-      classes = setup_duck_types(duck_types)
-      @condition_variable = classes[:condition_variable].new
+    def initialize(permit_count = 1)
+      raise 'not ready yet'
+      @condition_variable = UninterruptibleConditionVariable.new
       verify_permit_count(permit_count)
       @permit_count = permit_count
       @permits_used = 0
-      @mutex = ReentrantMutex.new(duck_types: duck_types)
+      @mutex = ::ReentrantMutex.new
     end
     
     # Check if a permit is available to be released.

data/lib/quack_concurrency/uninterruptible_condition_variable.rb

@@ -0,0 +1,79 @@
+module QuackConcurrency
+  class UninterruptibleConditionVariable
+  
+    def initialize
+      @waiting_threads_sleepers = []
+      @mutex = ::Mutex.new
+    end
+    
+    def any_waiting_threads?
+      waiting_threads_count >= 1
+    end
+    
+    def broadcast
+      @mutex.synchronize do
+        signal_next until @waiting_threads_sleepers.empty?
+      end
+      self
+    end
+    
+    def signal
+      @mutex.synchronize do
+        signal_next if @waiting_threads_sleepers.any?
+      end
+      self
+    end
+    
+    def wait(mutex = nil, timeout = nil)
+      validate_mutex(mutex)
+      if timeout != nil && !timeout.is_a?(Numeric)
+        raise ArgumentError, "'timeout' argument must be nil or a Numeric"
+      end
+      sleeper = UninterruptibleSleeper.for_current
+      @mutex.synchronize { @waiting_threads_sleepers.push(sleeper) }
+      if mutex
+        if mutex.respond_to?(:unlock!)
+          mutex.unlock! { sleep(sleeper, timeout) }
+        else
+          mutex.unlock
+          sleep(sleeper, timeout)
+          mutex.lock
+        end
+      else
+        sleep(sleeper, timeout)
+      end
+      @mutex.synchronize { @waiting_threads_sleepers.delete(sleeper) }
+      self
+    end
+    
+    def waiting_threads_count
+      @waiting_threads_sleepers.length
+    end
+    
+    private
+    
+    # @api private
+    def signal_next
+      next_waiting_thread_sleeper = @waiting_threads_sleepers.shift
+      next_waiting_thread_sleeper.run_thread if next_waiting_thread_sleeper
+      nil
+    end
+    
+    # @api private
+    def sleep(sleeper, duration)
+      if duration == nil || duration == Float::INFINITY
+        sleeper.stop_thread
+      else
+        sleeper.sleep_thread(timeout)
+      end
+      nil
+    end
+    
+    def validate_mutex(mutex)
+      return if mutex == nil
+      return if mutex.respond_to?(:lock) && (mutex.respond_to?(:unlock) || mutex.respond_to?(:unlock!))
+      raise ArgumentError, "'mutex' must respond to 'lock' and ('unlock' or'unlock!')"
+    end
+    
+  end
+end

data/lib/quack_concurrency/uninterruptible_sleeper.rb

@@ -0,0 +1,73 @@
+module QuackConcurrency
+  class UninterruptibleSleeper
+    
+    def self.for_current
+      new(Thread.current)
+    end
+    
+    def initialize(thread)
+      raise ArgumentError, "'thread' must be a Thread" unless thread.is_a?(Thread)
+      @thread = thread
+      @state = :running
+      @mutex = ::Mutex.new
+      @stop_called = false
+      @run_called = false
+    end
+    
+    def run_thread
+      @mutex.synchronize do
+        raise '#run_thread has already been called once' if @run_called
+        @run_called = true
+        return if @state == :running
+        Thread.pass until @state = :running || @thread.status == 'sleep'
+        @state = :running
+        @thread.run
+      end
+      nil
+    end
+    
+    def sleep_thread(duration)
+      start_time = Time.now
+      stop_thread(timeout: duration)
+      time_elapsed = Time.now - start_time
+    end
+    
+    def stop_thread(timeout: nil)
+      raise 'can only stop current Thread' unless Thread.current == @thread
+      raise "'timeout' argument must be nil or a Numeric" if timeout != nil && !timeout.is_a?(Numeric)
+      raise '#stop_thread has already been called once' if @stop_called
+      @stop_called = true
+      target_end_time = Time.now + timeout if timeout
+      @mutex.synchronize do
+        return if @run_called
+        @state = :sleeping
+        @mutex.unlock
+        loop do
+          if timeout
+            time_left = target_end_time - Time.now
+            Kernel.sleep(time_left) if time_left > 0
+          else
+            Thread.stop
+          end
+          break if @state == :running || Time.now >= target_time
+        end
+        @state = :running
+        
+        # we relock the mutex ensure #run_thread has finshed before #stop_thread
+        # if Thread#run is called by another part of the code at the same time as
+        #   #run_thread is being called, we dont want the call to #run_thread
+        #   to call Thread#run on a Thread has already resumed and stopped again
+        @mutex.lock
+      end
+      nil
+    end
+    
+    private
+    
+    # @api private
+    def current?
+      Thread.current == @thread
+    end
+    
+  end
+end

data/lib/quack_concurrency/waiter.rb

@@ -1,27 +1,57 @@
 module QuackConcurrency
-  class Waiter < ConcurrencyTool
+  
+  # @api private
+  class Waiter
   
     # Creates a new {Waiter} concurrency tool.
-    # @param duck_types [Hash] hash of core Ruby classes to overload.
-    #   If a +Hash+ is given, the keys +:condition_variable+ and +:mutex+ must be present.
     # @return [Waiter]
-    def initialize(duck_types: nil)
-      @queue = Queue.new(duck_types: duck_types)
+    def initialize
+      @condition_variable = UninterruptibleConditionVariable.new
+      @resume_all_forever = false
+      @mutex = ::Mutex.new
+    end
+    
+    def any_waiting_threads?
+      @condition_variable.any_waiting_threads?
+    end
+    
+    # Resumes all current and future waiting Thread.
+    # @return [void]
+    def resume_all
+      @condition_variable.broadcast
+      nil
     end
     
-    # Resumes next waiting thread.
-    # @param value value to pass to waiting thread
+    # Resumes all current and future waiting Thread.
     # @return [void]
-    def resume(value = nil)
-      @queue << value
+    def resume_all_forever
+      @mutex.synchronize do
+        @resume_all_forever = true
+        resume_all
+      end
       nil
     end
     
-    # Waits for another thread to resume the calling thread.
+    # Resumes next waiting Thread if one exists.
+    # @return [void]
+    def resume_one
+      @condition_variable.signal
+      nil
+    end
+    
+    # Waits for another Thread to resume the calling Thread.
     # @note Will block until resumed.
-    # @return value passed from resuming thread
+    # @return [void]
     def wait
-      @queue.pop
+      @mutex.synchronize do
+        return if @resume_all_forever
+        @condition_variable.wait(@mutex)
+      end
+      nil
+    end
+    
+    def waiting_threads_count
+      @condition_variable.waiting_threads_count
     end
     
   end

data/lib/quack_concurrency/yielder.rb

@@ -0,0 +1,35 @@
+# not ready yet
+
+module Threadesque
+  class SafeYielder
+    
+    def self.for_current
+      new(Thread.current)
+    end
+    
+    def initialize(thread)
+      raise 'not ready yet'
+      @thread = thread
+      @state = :running
+    end
+    
+    def resume
+      raise 'Thread is not sleeping' unless @state == :sleeping
+      :wait until @thread.status == 'sleep'
+      @state = :running
+      @thread.run
+      nil
+    end
+    
+    def yield
+      raise 'can only stop current Thread' unless Thread.current == @thread
+      @state = :sleeping
+      loop do
+        Thread.stop
+        redo if @state == :sleeping
+      end
+      nil
+    end
+    
+  end
+end

data/lib/quack_concurrency.rb

@@ -1,18 +1,19 @@
 require 'thread'
+require 'reentrant_mutex'
 
-require 'quack_concurrency/concurrency_tool'
+require 'quack_concurrency/condition_variable'
 require 'quack_concurrency/error'
 require 'quack_concurrency/future'
-require 'quack_concurrency/name'
-require 'quack_concurrency/queue'
-require 'quack_concurrency/reentrant_mutex'
-require 'quack_concurrency/semaphore'
-require 'quack_concurrency/waiter'
 require 'quack_concurrency/future/canceled'
 require 'quack_concurrency/future/complete'
+require 'quack_concurrency/mutex'
+require 'quack_concurrency/queue'
 require 'quack_concurrency/queue/error'
+require 'quack_concurrency/reentrant_mutex'
 require 'quack_concurrency/reentrant_mutex/error'
-require 'quack_concurrency/semaphore/error'
+require 'quack_concurrency/uninterruptible_condition_variable'
+require 'quack_concurrency/uninterruptible_sleeper'
+require 'quack_concurrency/waiter'
 
 
 # if you pass a duck type Hash to any of the concurrency tools it will force you to

data/spec/future_spec.rb

@@ -2,39 +2,6 @@ require 'quack_concurrency'
 
 RSpec.describe QuackConcurrency::Future do
   
-  describe "::new" do
-  
-    context "when called without a 'duck_types' argument" do
-      it "should create a new QuackConcurrency::Future" do
-        future = QuackConcurrency::Future.new
-        expect(future).to be_a(QuackConcurrency::Future)
-      end
-    end
-    
-    context "when called with 'condition_variable' and 'mutex' duck types" do
-      it "should create a new QuackConcurrency::Future" do
-        duck_types = {condition_variable: Class.new, mutex: Class.new}
-        future = QuackConcurrency::Future.new(duck_types: duck_types)
-        expect(future).to be_a(QuackConcurrency::Future)
-      end
-    end
-    
-    context "when called with only 'condition_variable' duck type" do
-      it "should raise ArgumentError" do
-        duck_types = {condition_variable: Class.new}
-        expect{ QuackConcurrency::Future.new(duck_types: duck_types) }.to raise_error(ArgumentError)
-      end
-    end
-    
-    context "when called with only 'mutex' duck type" do
-      it "should raise ArgumentError" do
-        duck_types = {mutex: Class.new}
-        expect{ QuackConcurrency::Future.new(duck_types: duck_types) }.to raise_error(ArgumentError)
-      end
-    end
-    
-  end
-  
   describe "#set" do
   
     context "when called" do
@@ -97,7 +64,7 @@ RSpec.describe QuackConcurrency::Future do
         future = QuackConcurrency::Future.new
         thread = Thread.new do
           sleep 1
-          future.set 1
+          future.set(1)
         end
         start_time = Time.now
         expect(future.get).to eql 1

data/spec/queue_spec.rb

@@ -2,39 +2,6 @@ require 'quack_concurrency'
 
 RSpec.describe QuackConcurrency::Queue do
   
-  describe "::new" do
-  
-    context "when called without a 'duck_types' argument" do
-      it "should create a new QuackConcurrency::Queue" do
-        queue = QuackConcurrency::Queue.new
-        expect(queue).to be_a(QuackConcurrency::Queue)
-      end
-    end
-    
-    context "when called with 'condition_variable' and 'mutex' duck types" do
-      it "should create a new QuackConcurrency::Queue" do
-        duck_types = {condition_variable: Class.new, mutex: Class.new}
-        queue = QuackConcurrency::Queue.new(duck_types: duck_types)
-        expect(queue).to be_a(QuackConcurrency::Queue)
-      end
-    end
-    
-    context "when called with only 'condition_variable' duck type" do
-      it "should raise ArgumentError" do
-        duck_types = {condition_variable: Class.new}
-        expect{ QuackConcurrency::Queue.new(duck_types: duck_types) }.to raise_error(ArgumentError)
-      end
-    end
-    
-    context "when called with only 'mutex' duck type" do
-      it "should raise ArgumentError" do
-        duck_types = {mutex: Class.new}
-        expect{ QuackConcurrency::Queue.new(duck_types: duck_types) }.to raise_error(ArgumentError)
-      end
-    end
-    
-  end
-  
   describe "#push" do
   
     context "when called many times when queue is not closed" do
@@ -52,7 +19,7 @@ RSpec.describe QuackConcurrency::Queue do
     context "when #pop is called with non_block set to true" do
       it "should raise Error" do
         queue = QuackConcurrency::Queue.new
-        expect{ queue.pop(true) }.to raise_error(QuackConcurrency::Queue::Error)
+        expect{ queue.pop(true) }.to raise_error(ThreadError)
       end
     end
     

data/spec/reentrant_mutex_spec.rb

@@ -2,39 +2,6 @@ require 'quack_concurrency'
 
 RSpec.describe QuackConcurrency::ReentrantMutex do
   
-  describe "::new" do
-  
-    context "when called without a 'duck_types' argument" do
-      it "should create a new QuackConcurrency::ReentrantMutex" do
-        mutex = QuackConcurrency::ReentrantMutex.new
-        expect(mutex).to be_a(QuackConcurrency::ReentrantMutex)
-      end
-    end
-    
-    context "when called with 'condition_variable' and 'mutex' duck types" do
-      it "should create a new QuackConcurrency::ReentrantMutex" do
-        duck_types = {condition_variable: Class.new, mutex: Class.new}
-        mutex = QuackConcurrency::ReentrantMutex.new(duck_types: duck_types)
-        expect(mutex).to be_a(QuackConcurrency::ReentrantMutex)
-      end
-    end
-    
-    context "when called with only 'condition_variable' duck type" do
-      it "should raise ArgumentError" do
-        duck_types = {condition_variable: Class.new}
-        expect{ QuackConcurrency::ReentrantMutex.new(duck_types: duck_types) }.to raise_error(ArgumentError)
-      end
-    end
-    
-    context "when called with only 'mutex' duck type" do
-      it "should raise ArgumentError" do
-        duck_types = {mutex: Class.new}
-        expect{ QuackConcurrency::ReentrantMutex.new(duck_types: duck_types) }.to raise_error(ArgumentError)
-      end
-    end
-    
-  end
-  
   describe "#lock" do
   
     context "when called for first time" do
@@ -164,6 +131,8 @@ RSpec.describe QuackConcurrency::ReentrantMutex do
       it "should wait for that time" do
         mutex = QuackConcurrency::ReentrantMutex.new
         start_time = Time.now
+        #require 'pry'
+        #binding.pry
         mutex.synchronize do
           mutex.sleep(1)
         end