quack_concurrency 0.5.4 → 0.6.0

data/lib/quack_concurrency/uninterruptible_sleeper.rb

@@ -1,81 +0,0 @@
-module QuackConcurrency
-
-  # An {UninterruptibleSleeper} can be used to safely sleep a `Thread`.
-  # Unlike simply calling `Thread#sleep`, {#stop_thread} will ensure that only
-  # calling {#run_thread} on this {UninterruptibleSleeper} will wake the `Thread`.
-  # Any call to `Thread#run` directly, will be ignored.
-  # `Thread`s can still be resumed if `Thread#raise` is called.
-  # A `ThreadError` will be raised if a the last running `Thread` is stopped.
-  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 # may raise ThreadError if this is last running Thread
-          end
-          break if @state == :running || Time.now >= target_time
-        end
-      ensure
-        @state = :running
-        
-        # we relock the mutex to 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/yielder.rb

@@ -1,35 +0,0 @@
-# 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/spec/semaphore_spec.rb

@@ -1,244 +0,0 @@
-#require 'quack_concurrency'
-
-#RSpec.describe QuackConcurrency::Semaphore do
-  
-  #describe "#release" do
-  
-    #context "when called for the first time with many permits available" do
-      #it "should not raise error" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        
-        #expect{ semaphore.release }.not_to raise_error
-      #end
-    #end
-    
-    #context "when called a second time with one permit available" do
-      #it "should not raise error" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #semaphore.release
-        #expect{ semaphore.release }.not_to raise_error
-      #end
-    #end
-  
-  #end
-  
-  #describe "#release, #reacquire" do
-    
-    #context "when #release called with no permits available" do
-      #it "should wait until #reacquire is called" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #semaphore.release
-        #semaphore.release
-        #thread = Thread.new do
-          #sleep 1
-          #semaphore.reacquire
-        #end
-        #start_time = Time.now
-        #semaphore.release
-        #end_time = Time.now
-        #duration = end_time - start_time
-        #thread.join
-        #expect(duration).to be > 0.5
-      #end
-    #end
-    
-    #context "when #reacquire called when all permits are available" do
-      #it "should raise QuackConcurrency::Semaphore::Error" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #expect{ semaphore.reacquire }.to raise_error(QuackConcurrency::Semaphore::Error)
-      #end
-    #end
-    
-  #end
-  
-  #describe "#release, #reacquire, #permit_available?, #permits_available" do
-  
-    #context "#permit_available? and #permits_available" do
-      #it "should work as expected" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #expect(semaphore.permit_available?).to eql true
-        #expect(semaphore.permits_available).to eql 2
-        #semaphore.release
-        #expect(semaphore.permit_available?).to eql true
-        #expect(semaphore.permits_available).to eql 1
-        #semaphore.release
-        #expect(semaphore.permit_available?).to eql false
-        #expect(semaphore.permits_available).to eql 0
-        #semaphore.reacquire
-        #expect(semaphore.permit_available?).to eql true
-        #expect(semaphore.permits_available).to eql 1
-        #semaphore.reacquire
-        #expect(semaphore.permit_available?).to eql true
-        #expect(semaphore.permits_available).to eql 2
-      #end
-    #end
-    
-  #end
-  
-  #describe "#set_permit_count, #permits_available" do
-  
-    #context "when #set_permit_count is called with more permits then currently exist" do
-      #it "should add permits" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #expect(semaphore.permits_available).to eql 2
-        #semaphore.set_permit_count(3)
-        #expect(semaphore.permits_available).to eql 3
-      #end
-    #end
-    
-    #context "when #set_permit_count is called with less permits then currently exist" do
-      #it "should remove permits" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #expect(semaphore.permits_available).to eql 2
-        #semaphore.set_permit_count(1)
-        #expect(semaphore.permits_available).to eql 1
-      #end
-    #end
-  
-  #end
-  
-  #describe "#set_permit_count, #permits_available, #release" do
-    
-    #context "when #set_permit_count is called with less permits then currently available" do
-      #it "should raise QuackConcurrency::Semaphore::Error" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #expect(semaphore.permits_available).to eql 2
-        #semaphore.release
-        #semaphore.release
-        #expect{ semaphore.set_permit_count(1) }.to raise_error(QuackConcurrency::Semaphore::Error)
-      #end
-    #end
-    
-  #end
-  
-  #describe "#set_permit_count, #release" do
-  
-    #context "when #set_permit_count is called with more permits when one thread is waiting on #release" do
-      #it "should resume the thread" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #semaphore.release
-        #semaphore.release
-        #thread = Thread.new do
-          #sleep 1
-          #semaphore.set_permit_count(3)
-        #end
-        #start_time = Time.now
-        #semaphore.release
-        #end_time = Time.now
-        #duration = end_time - start_time
-        #thread.join
-        #expect(duration).to be > 0.5
-      #end
-    #end
-    
-  #end
-  
-  #describe "#set_permit_count!, #permits_available" do
-  
-    #context "when #set_permit_count! is called with more permits then currently exist" do
-      #it "should add permits" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #expect(semaphore.permits_available).to eql 2
-        #semaphore.set_permit_count!(3)
-        #expect(semaphore.permits_available).to eql 3
-      #end
-    #end
-    
-    #context "when #set_permit_count! is called with less permits then currently exist" do
-      #it "should remove permits" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #expect(semaphore.permits_available).to eql 2
-        #semaphore.set_permit_count!(1)
-        #expect(semaphore.permits_available).to eql 1
-      #end
-    #end
-  
-  #end
-  
-  #describe "#set_permit_count!, #permits_available, #release, #reacquire" do
-    
-    #context "when #set_permit_count! is called with less permits then currently available" do
-      #it "should force new permit count" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #expect(semaphore.permits_available).to eql 2
-        #semaphore.release
-        #semaphore.release
-        #semaphore.set_permit_count!(1)
-        #expect(semaphore.permit_available?).to eql false
-        #semaphore.reacquire
-        #expect(semaphore.permit_available?).to eql false
-        #semaphore.reacquire
-        #expect(semaphore.permit_available?).to eql true
-      #end
-    #end
-    
-  #end
-  
-  #describe "#set_permit_count!, #release" do
-  
-    #context "when #set_permit_count! is called with more permits when one thread is waiting on #release" do
-      #it "should resume the thread" do
-        #semaphore = QuackConcurrency::Semaphore.new(2)
-        #semaphore.release
-        #semaphore.release
-        #thread = Thread.new do
-          #sleep 1
-          #semaphore.set_permit_count(3)
-        #end
-        #start_time = Time.now
-        #semaphore.release
-        #end_time = Time.now
-        #duration = end_time - start_time
-        #thread.join
-        #expect(duration).to be > 0.5
-      #end
-    #end
-    
-  #end
-  
-  #describe "#set_permit_count!, #release, #permit_available?" do
-  
-    #context "when semaphore has no permits available, them #set_permit_count! is called to remove 2 permits, then called again to add 1 permit" do
-      #it "should not have any permits available" do
-        #semaphore = QuackConcurrency::Semaphore.new(3)
-        #semaphore.release
-        #semaphore.release
-        #expect(semaphore.permit_available?).to eql true
-        #semaphore.set_permit_count!(1)
-        #expect(semaphore.permit_available?).to eql false
-        #semaphore.set_permit_count!(2)
-        #expect(semaphore.permit_available?).to eql false
-      #end
-    #end
-    
-  #end
-  
-  #describe "#set_permit_count!, #release, #reacquire" do
-  
-    #context "when semaphore has no permits available, them #set_permit_count! is called to remove 2 permits, then a thread starts waiting for #release, then #set_permit_count! is called again to add 1 permit" do
-      #it "thread should wait for #reacquire to be called" do
-        #semaphore = QuackConcurrency::Semaphore.new(3)
-        #semaphore.release
-        #semaphore.release
-        #semaphore.release
-        #semaphore.set_permit_count!(1)
-        #thread = Thread.new do
-          #sleep 1
-          #semaphore.set_permit_count!(2)
-          #sleep 1
-          #semaphore.reacquire
-          #sleep 1
-          #semaphore.reacquire
-        #end
-        #start_time = Time.now
-        #semaphore.release
-        #end_time = Time.now
-        #duration = end_time - start_time
-        #thread.join
-        #expect(duration).to be_between(2.5, 3.5)
-      #end
-    #end
-    
-  #end
-
-#end