quack_concurrency 0.5.4 → 0.6.0

data/spec/waiter_spec.rb

@@ -0,0 +1,181 @@
+require 'quack_concurrency'
+
+describe QuackConcurrency::Waiter do
+
+  # arbitrary amount of time we will wait for everything to settle
+  def delay(units = 1)
+    sleep units
+  end
+
+  describe "::new" do
+
+    context "when called with no arguments" do
+      waiter = nil
+      it "should not raise error" do
+        expect{ waiter = QuackConcurrency::Waiter.new }.not_to raise_error
+      end
+      it "should return a Waiter" do
+        expect(waiter).to be_a(QuackConcurrency::Waiter)
+      end
+    end
+
+  end
+
+  describe "#any_waiting_threads?" do
+
+    context "when called with waiting threads" do
+      it "should return true" do
+        waiter = QuackConcurrency::Waiter.new
+        thread = Thread.new { waiter.wait }
+        delay(1)
+        expect(waiter.any_waiting_threads?).to be true
+        waiter.resume_all
+        thread.join
+      end
+    end
+
+    context "when called with no waiting threads" do
+      it "should return false" do
+        waiter = QuackConcurrency::Waiter.new
+        expect(waiter.any_waiting_threads?).to be false
+      end
+    end
+
+  end
+
+  describe "#resume_all" do
+
+    context "when called" do
+      it "should resume all threads currently waiting" do
+        waiter = QuackConcurrency::Waiter.new
+        thread1 = Thread.new { waiter.wait }
+        thread2 = Thread.new { waiter.wait }
+        delay(1)
+        waiter.resume_all
+        delay(1)
+        expect(thread1.alive?).to be false
+        expect(thread2.alive?).to be false
+      end
+      it "should not resume any future threads that call #wait" do
+        waiter = QuackConcurrency::Waiter.new
+        waiter.resume_all
+        thread = Thread.new { waiter.wait }
+        delay(1)
+        expect(thread.alive?).to be true
+        waiter.resume_all
+        thread.join
+      end
+    end
+
+  end
+
+  describe "#resume_all_indefinitely" do
+
+    context "when called" do
+      it "should resume all threads currently waiting" do
+        waiter = QuackConcurrency::Waiter.new
+        thread1 = Thread.new { waiter.wait }
+        thread2 = Thread.new { waiter.wait }
+        delay(1)
+        waiter.resume_all_indefinitely
+        delay(1)
+        expect(thread1.alive?).to be false
+        expect(thread2.alive?).to be false
+      end
+      it "should resume all future threads that call #wait" do
+        waiter = QuackConcurrency::Waiter.new
+        waiter.resume_all_indefinitely
+        thread1 = Thread.new { waiter.wait }
+        thread2 = Thread.new { waiter.wait }
+        delay(1)
+        expect(thread1.alive?).to be false
+        expect(thread2.alive?).to be false
+      end
+    end
+
+  end
+
+  describe "#resume_next" do
+
+    context "when called" do
+      it "should resume the next thread currently waiting" do
+        waiter = QuackConcurrency::Waiter.new
+        thread1 = Thread.new { waiter.wait }
+        delay(1)
+        thread2 = Thread.new { waiter.wait }
+        delay(1)
+        waiter.resume_next
+        delay(1)
+        expect(thread1.alive?).to be false
+        expect(thread2.alive?).to be true
+        waiter.resume_next
+        delay(1)
+        expect(thread2.alive?).to be false
+      end
+    end
+
+  end
+
+  describe "#wait" do
+
+    context "when called" do
+      it "should return only after one of the resume methods are called" do
+        waiter = QuackConcurrency::Waiter.new
+        thread1 = Thread.new { waiter.wait }
+        thread2 = Thread.new { waiter.wait }
+        delay(1)
+        expect(thread1.alive?).to be true
+        expect(thread2.alive?).to be true
+        waiter.resume_all
+        thread1.join
+        thread2.join
+      end
+    end
+
+    context "when called before Thread#run" do
+      it "should return only after one of the resume methods are called" do
+        waiter = QuackConcurrency::Waiter.new
+        elapsed_time = nil
+        thread = Thread.new { waiter.wait }
+        delay(1)
+        thread.run
+        delay(1)
+        expect(thread.alive?).to be true
+        waiter.resume_all
+        delay(1)
+        expect(thread.alive?).to be false
+      end
+    end
+
+  end
+
+  describe "#waiting_threads_count" do
+
+    context "when called" do
+      it "should return a Integer" do
+        waiter = QuackConcurrency::Waiter.new
+        expect(waiter.waiting_threads_count).to be_a(Integer)
+      end
+    end
+
+    context "when called with no waiting threads" do
+      it "should return 0" do
+        waiter = QuackConcurrency::Waiter.new
+        expect(waiter.waiting_threads_count).to be 0
+      end
+    end
+
+    context "when called with one waiting thread" do
+      it "should return 1" do
+        waiter = QuackConcurrency::Waiter.new
+        thread = Thread.new { waiter.wait }
+        delay(1)
+        expect(waiter.waiting_threads_count).to be 1
+        waiter.resume_next
+        thread.join
+      end
+    end
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quack_concurrency
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors:
 - Rob Fors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-18 00:00:00.000000000 Z
+date: 2018-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reentrant_mutex
@@ -25,8 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.1'
 description: Offers concurrency tools that could also be found in the 'Concurrent
-  Ruby'. However, all these tools will also accept core class duck types to build
-  off of.
+  Ruby'. However, all these tools will also accept core duck types to build off of.
 email: mail@robfors.com
 executables: []
 extensions: []
@@ -37,26 +36,29 @@ files:
 - Rakefile
 - lib/quack_concurrency.rb
 - lib/quack_concurrency/condition_variable.rb
+- lib/quack_concurrency/condition_variable/waitable.rb
 - lib/quack_concurrency/error.rb
 - lib/quack_concurrency/future.rb
 - lib/quack_concurrency/future/canceled.rb
 - lib/quack_concurrency/future/complete.rb
 - lib/quack_concurrency/mutex.rb
 - lib/quack_concurrency/queue.rb
-- lib/quack_concurrency/queue/error.rb
 - lib/quack_concurrency/reentrant_mutex.rb
-- lib/quack_concurrency/reentrant_mutex/error.rb
-- lib/quack_concurrency/semaphore.rb
-- lib/quack_concurrency/semaphore/error.rb
-- lib/quack_concurrency/uninterruptible_condition_variable.rb
-- lib/quack_concurrency/uninterruptible_sleeper.rb
+- lib/quack_concurrency/safe_condition_variable.rb
+- lib/quack_concurrency/safe_condition_variable/waitable.rb
+- lib/quack_concurrency/safe_sleeper.rb
+- lib/quack_concurrency/sleeper.rb
 - lib/quack_concurrency/waiter.rb
-- lib/quack_concurrency/yielder.rb
+- spec/condition_variable_spec.rb
 - spec/future_spec.rb
+- spec/mutex_spec.rb
 - spec/queue_spec.rb
 - spec/reentrant_mutex_spec.rb
-- spec/semaphore_spec.rb
+- spec/safe_condition_variable_spec.rb
+- spec/safe_sleeper_spec.rb
+- spec/sleeper.rb
 - spec/spec_helper.rb
+- spec/waiter_spec.rb
 homepage: https://github.com/robfors/quack_concurrency
 licenses:
 - MIT
@@ -77,8 +79,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
-summary: Concurrency tools that accept duck types of core classes.
+summary: Concurrency tools with modifiable blocking behaviour.
 test_files: []

data/lib/quack_concurrency/queue/error.rb

@@ -1,6 +0,0 @@
-module QuackConcurrency
-  class Queue
-    class Error < Error
-    end
-  end
-end

data/lib/quack_concurrency/reentrant_mutex/error.rb

@@ -1,6 +0,0 @@
-module QuackConcurrency
-  class ReentrantMutex
-    class Error < Error
-    end
-  end
-end

data/lib/quack_concurrency/semaphore.rb

@@ -1,139 +0,0 @@
-# not ready yet
-
-module QuackConcurrency
-  class Semaphore
-  
-    # Gets total permit count
-    # @return [Integer]
-    attr_reader :permit_count
-    
-    # Creates a new {Semaphore} concurrency tool.
-    # @return [Semaphore]
-    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
-    end
-    
-    # Check if a permit is available to be released.
-    # @return [Boolean]
-    def permit_available?
-      permits_available >= 1
-    end
-    
-    # Counts number of permits available to be released.
-    # @return [Integer]
-    def permits_available
-      @mutex.synchronize do
-        raw_permits_available = @permit_count - @permits_used
-        raw_permits_available.positive? ? raw_permits_available : 0
-      end
-    end
-    
-    # Returns a permit so it can be released again in the future.
-    # @return [void]
-    def reacquire
-      @mutex.synchronize do
-        raise Error, 'can not reacquire a permit, no permits released right now' if @permits_used == 0
-        @permits_used -= 1
-        @condition_variable.signal if permit_available?
-      end
-      nil
-    end
-    
-    # Releases a permit.
-    # @note Will block until a permit is available.
-    # @return [void]
-    def release
-      @mutex.synchronize do
-        @condition_variable.wait(@mutex) unless permit_available?
-        raise 'internal error, invalid state' unless permit_available?
-        @permits_used += 1
-      end
-      nil
-    end
-    
-    # Changes the permit count after {Semaphore} has been created.
-    # @raise [Error] if total permit count is reduced and not enough permits are available to remove
-    # @return [void]
-    def set_permit_count(new_permit_count)
-      verify_permit_count(new_permit_count)
-      @mutex.synchronize do
-        remove_permits = @permit_count - new_permit_count
-        if remove_permits.positive? && remove_permits > permits_available
-          raise Error, 'can not set new permit count, not enough permits available to remove right now'
-        end
-        set_permit_count!(new_permit_count)
-      end
-      nil
-    end
-    
-    # Changes the permit count after {Semaphore} has been created.
-    # If total permit count is reduced and not enough permits are available to remove,
-    # it will change the count anyway but some permits will need to be reacquired
-    # before any can be released.
-    # @return [void]
-    def set_permit_count!(new_permit_count)
-      verify_permit_count(new_permit_count)
-      @mutex.synchronize do
-        new_permits = new_permit_count - @permit_count
-        if new_permits.positive?
-          new_permits.times { add_permit }
-        else
-          remove_permits = -new_permits
-          remove_permits.times { remove_permit! }
-        end
-      end
-      nil
-    end
-    
-    # Releases a permit, runs the block, and reacquires the permit when the block completes.
-    # @return return value from yielded block
-    def synchronize
-      release
-      begin
-        yield
-      ensure
-        reacquire
-      end
-    end
-    
-    # Attempts to release a permit and returns immediately.
-    # @return [Boolean] returns if the permit was released
-    def try_release
-      @mutex.synchronize do
-        if permit_available?
-          release
-          true
-        else
-          false
-        end
-      end
-    end
-    
-    private
-    
-    def add_permit
-      @permit_count += 1
-      @condition_variable.signal if permit_available?
-      nil
-    end
-    
-    def remove_permit!
-      @permit_count -= 1
-      raise 'internal error, invalid state' if @permit_count < 0
-      nil
-    end
-    
-    def verify_permit_count(permit_count)
-      unless permit_count.is_a?(Integer) && permit_count >= 0
-        raise ArgumentError, "'permit_count' must be a non negative Integer"
-      end
-    end
-    
-  end
-end
-  

data/lib/quack_concurrency/semaphore/error.rb

@@ -1,6 +0,0 @@
-module QuackConcurrency
-  class Semaphore
-    class Error < Error
-    end
-  end
-end

data/lib/quack_concurrency/uninterruptible_condition_variable.rb

@@ -1,94 +0,0 @@
-module QuackConcurrency
-
-  # Unlike `::ConditionVariable` {UninterruptibleConditionVariable} will
-  # safely sleep a `Thread`s. Any calls to `Thread#run` directly, will be ignored.
-  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
-        # ideally we would would check if this Thread can sleep (not the last Thread alive)
-        #   before we unlock the mutex, however I am not sure is that can be implemented
-        if mutex.respond_to?(:unlock!)
-          mutex.unlock! { sleep(sleeper, timeout) }
-        else
-          mutex.unlock
-          begin
-            sleep(sleeper, timeout)
-          ensure # rescue a fatal error (eg. only Thread stopped)
-            if mutex.locked?
-              # another Thread locked this before it died
-              # this is not a correct state to be in but I don't know how to fix it
-              # given that there are no other alive Threads then than the ramifications should be minimal
-            else
-              mutex.lock
-            end
-          end
-        end
-      else
-        sleep(sleeper, timeout)
-      end
-      self
-    ensure
-      @mutex.synchronize { @waiting_threads_sleepers.delete(sleeper) }
-    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