quack_concurrency 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c6822c50d1a8483a8009ad94e2725691bf28a71d3e9441d67b092c6b96314db
-  data.tar.gz: 47a4c773d831b66fe2b40db8ca23f7cb3c44962023ff1e7fc7cc4a4832bc41b9
+  metadata.gz: d110c1994e7796f45c3cade0f82f7bae2ce8daa0fa775e32fe92cb5a5d1bb3e7
+  data.tar.gz: 1253c01f31d051a5cdccd599c3d1ce597bc580c9e06311727b132aa4e1f2e172
 SHA512:
-  metadata.gz: 7aebe4c95df5578c5a68d4331965dd6d68763ffd51e2683cc9aa345be9148b77f060914af76a728c3c394a9bb56ceb8f142a59855a22e6c833a9253f957235ba
-  data.tar.gz: 1f406ab37a50d2d58f2a4952e1ed7f6152d050fa2d723c9477e8ab6cc9cd540dc31fa72b805027bc98c09d0fa73ae641f3d9e85f523cf91facb0f463be19df6c
+  metadata.gz: c44997c7c973429240bbf600ea68818eedb548012ccc0248028a4fc5a18509e9050b44baa92c563190512c1cb34a0999d8624288827915eb4dcdbc05997961ad
+  data.tar.gz: 99f22237f7a44ea60ac10c0a25c8ac6627fa17cf13de2f55e4797a749607f676dd02ffbfd47ade2f93a983e5ca83dab89e8374480ab930326154e47c14d69c36

data/lib/quack_concurrency/condition_variable.rb

@@ -61,18 +61,30 @@ module QuackConcurrency
       end
       @mutex.synchronize { @waiting_threads.push(caller) }
       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(timeout) }
         else
           mutex.unlock
-          sleep(timeout)
-          mutex.lock
+          begin
+            sleep(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(timeout)
       end
-      @mutex.synchronize { @waiting_threads.delete(caller) }
       self
+    ensure
+      @mutex.synchronize { @waiting_threads.delete(caller) }
     end
     
     # Returns the number of `Thread`s currently waiting.

data/lib/quack_concurrency/uninterruptible_condition_variable.rb

@@ -35,18 +35,30 @@ module QuackConcurrency
       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
-          sleep(sleeper, timeout)
-          mutex.lock
+          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
-      @mutex.synchronize { @waiting_threads_sleepers.delete(sleeper) }
       self
+    ensure
+      @mutex.synchronize { @waiting_threads_sleepers.delete(sleeper) }
     end
     
     def waiting_threads_count
@@ -54,7 +66,7 @@ module QuackConcurrency
     end
     
     private
-    
+
     # @api private
     def signal_next
       next_waiting_thread_sleeper = @waiting_threads_sleepers.shift

data/lib/quack_concurrency/uninterruptible_sleeper.rb

@@ -4,6 +4,8 @@ module QuackConcurrency
   # 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
@@ -52,13 +54,14 @@ module QuackConcurrency
             time_left = target_end_time - Time.now
             Kernel.sleep(time_left) if time_left > 0
           else
-            Thread.stop
+            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 ensure #run_thread has finshed before #stop_thread
+        # 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quack_concurrency
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Rob Fors