atomic-ruby 0.15.1 → 0.15.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af7a35affcaa2790e6944ee01eb6af8f4d92b5c2479bb1995128742a562fd395
-  data.tar.gz: d3908277e6ef09a70f7d46a057a5db7f60c179885d980b4fbbf407bdade6b073
+  metadata.gz: a50be9a8594152f8d07b2338588a01be6aecadf55f993ea6cc4c2431e80e2b76
+  data.tar.gz: eb9c45d8dff70d0697d3d62ba5a539e3d71e42c21ea7ab6b646d44fde69f39ac
 SHA512:
-  metadata.gz: f5a3525b194636ddb439c0c8e9597e3ed1870a8c0165bc1582cb120a45c49b30a8cf6bd60f393a9e3e0c848abf760b181dce1b9b3026199ff8ffb2ba833dcc1a
-  data.tar.gz: e89a1f593774fc1722bfc8a9229385682e33a10df705ba78da3c67f904ab566c770b7aebdebc32069ed7f4dfc2781ad52165f08f10cf3fd4e4d723c41687e02f
+  metadata.gz: abde2bc85010be3634caeaf66d262acf1c5c70c50af5e9e420a43c87071965bd543a475b01b5d1b0d1569682802595e936a9d224e636896a681e5c3c85d98a77
+  data.tar.gz: e93d7b35c3ccdba9c82906587c24455c248655ffbe3f9d4141e4cb029705306f80c13b36f6a0ce7193a33701758ad0a9c2f77a7aa0c94ad92e49392ba899c055

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [0.15.2] - 2026-08-31
+
+- Prevent enqueues from racing `AtomicThreadPool#shutdown`
+- Remove interrupted waiters from `AtomicConditionVariable`
+- Replace `Thread.pass` busy-wait with `sleep` in `AtomicCountDownLatch#wait`
+
+## [0.15.2] - 2026-08-30
+
+- Avoid thread event hook overhead for fixed thread pools
+
 ## [0.15.1] - 2026-08-30
 
 - Prevent OS scheduling delays from stopping adaptive thread pool growth

data/README.md

@@ -267,8 +267,8 @@ puts "Atomic Ruby Atomic Bank Account:     #{results[2].real.round(6)} seconds"
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atom_benchmark.rb
 
 ruby version:            ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
-concurrent-ruby version: 1.3.6
-atomic-ruby version:     0.15.1
+concurrent-ruby version: 1.3.8
+atomic-ruby version:     0.15.3
 
 Balances:
 Synchronized Bank Account Balance:           975
@@ -276,9 +276,9 @@ Concurrent Ruby Atomic Bank Account Balance: 975
 Atomic Ruby Atomic Bank Account Balance:     975
 
 Benchmark Results:
-Synchronized Bank Account:           5.117072 seconds
-Concurrent Ruby Atomic Bank Account: 5.128366 seconds
-Atomic Ruby Atomic Bank Account:     5.110595 seconds
+Synchronized Bank Account:           5.104959 seconds
+Concurrent Ruby Atomic Bank Account: 5.120305 seconds
+Atomic Ruby Atomic Bank Account:     5.102732 seconds
 ```
 
 </details>
@@ -358,22 +358,22 @@ end
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_boolean_benchmark.rb
 
 ruby version:            ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
-concurrent-ruby version: 1.3.6
-atomic-ruby version:     0.15.1
+concurrent-ruby version: 1.3.8
+atomic-ruby version:     0.15.3
 
 Warming up --------------------------------------
-          Synchronized Boolean Toggle   157.000 i/100ms
-Concurrent Ruby Atomic Boolean Toggle   134.000 i/100ms
-    Atomic Ruby Atomic Boolean Toggle   120.000 i/100ms
+          Synchronized Boolean Toggle   165.000 i/100ms
+Concurrent Ruby Atomic Boolean Toggle   132.000 i/100ms
+    Atomic Ruby Atomic Boolean Toggle   119.000 i/100ms
 Calculating -------------------------------------
-          Synchronized Boolean Toggle      1.629k (± 2.0%) i/s  (613.87 μs/i) -      8.164k in   5.011636s
-Concurrent Ruby Atomic Boolean Toggle      1.325k (± 2.0%) i/s  (754.96 μs/i) -      6.700k in   5.058203s
-    Atomic Ruby Atomic Boolean Toggle      1.190k (± 2.6%) i/s  (840.11 μs/i) -      6.000k in   5.040665s
+          Synchronized Boolean Toggle      1.647k (± 2.1%) i/s  (606.98 μs/i) -      8.250k in   5.007598s
+Concurrent Ruby Atomic Boolean Toggle      1.343k (± 1.9%) i/s  (744.55 μs/i) -      6.732k in   5.012307s
+    Atomic Ruby Atomic Boolean Toggle      1.207k (± 1.9%) i/s  (828.31 μs/i) -      6.069k in   5.027033s
 
 Comparison:
-          Synchronized Boolean Toggle:     1629.0 i/s
-Concurrent Ruby Atomic Boolean Toggle:     1324.6 i/s - 1.23x  slower
-    Atomic Ruby Atomic Boolean Toggle:     1190.3 i/s - 1.37x  slower
+          Synchronized Boolean Toggle:     1647.5 i/s
+Concurrent Ruby Atomic Boolean Toggle:     1343.1 i/s - 1.23x  slower
+    Atomic Ruby Atomic Boolean Toggle:     1207.3 i/s - 1.36x  slower
 ```
 
 </details>
@@ -442,18 +442,18 @@ end
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_condition_variable_benchmark.rb
 
 ruby version:        ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
-atomic-ruby version: 0.15.1
+atomic-ruby version: 0.15.3
 
 Warming up --------------------------------------
-      Synchronized Condition Variable Wait/Signal     3.977k i/100ms
-Atomic Ruby Atomic Condition Variable Wait/Signal     3.885k i/100ms
+      Synchronized Condition Variable Wait/Signal     4.062k i/100ms
+Atomic Ruby Atomic Condition Variable Wait/Signal     4.133k i/100ms
 Calculating -------------------------------------
-      Synchronized Condition Variable Wait/Signal     39.458k (± 4.2%) i/s   (25.34 μs/i) -    198.850k in   5.039596s
-Atomic Ruby Atomic Condition Variable Wait/Signal     39.046k (± 4.2%) i/s   (25.61 μs/i) -    198.135k in   5.074411s
+      Synchronized Condition Variable Wait/Signal     41.923k (± 3.5%) i/s   (23.85 μs/i) -    211.224k in   5.038330s
+Atomic Ruby Atomic Condition Variable Wait/Signal     40.666k (± 3.8%) i/s   (24.59 μs/i) -    206.650k in   5.081595s
 
 Comparison:
-      Synchronized Condition Variable Wait/Signal:    39457.5 i/s
-Atomic Ruby Atomic Condition Variable Wait/Signal:    39045.9 i/s - same-ish: difference falls within error
+      Synchronized Condition Variable Wait/Signal:    41923.4 i/s
+Atomic Ruby Atomic Condition Variable Wait/Signal:    40666.4 i/s - same-ish: difference falls within error
 ```
 
 </details>
@@ -517,18 +517,18 @@ end
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_queue_benchmark.rb
 
 ruby version:        ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
-atomic-ruby version: 0.15.1
+atomic-ruby version: 0.15.3
 
 Warming up --------------------------------------
-      Synchronized Queue Push/Pop   181.000 i/100ms
-Atomic Ruby Atomic Queue Push/Pop   132.000 i/100ms
+      Synchronized Queue Push/Pop   184.000 i/100ms
+Atomic Ruby Atomic Queue Push/Pop   149.000 i/100ms
 Calculating -------------------------------------
-      Synchronized Queue Push/Pop      1.845k (± 2.1%) i/s  (541.91 μs/i) -      9.231k in   5.002394s
-Atomic Ruby Atomic Queue Push/Pop      1.431k (± 6.8%) i/s  (698.64 μs/i) -      7.260k in   5.072143s
+      Synchronized Queue Push/Pop      1.819k (± 2.0%) i/s  (549.73 μs/i) -      9.200k in   5.057550s
+Atomic Ruby Atomic Queue Push/Pop      1.493k (± 1.9%) i/s  (669.87 μs/i) -      7.599k in   5.090319s
 
 Comparison:
-      Synchronized Queue Push/Pop:     1845.3 i/s
-Atomic Ruby Atomic Queue Push/Pop:     1431.3 i/s - 1.29x  slower
+      Synchronized Queue Push/Pop:     1819.1 i/s
+Atomic Ruby Atomic Queue Push/Pop:     1492.8 i/s - 1.22x  slower
 
 ```
 
@@ -587,11 +587,69 @@ puts "Atomic Ruby Atomic Thread Pool: #{results[1].real.round(6)} seconds"
 
 ruby version:            ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
 concurrent-ruby version: 1.3.8
-atomic-ruby version:     0.15.1
+atomic-ruby version:     0.15.3
+
+Benchmark Results:
+Concurrent Ruby Thread Pool:    5.012798 seconds
+Atomic Ruby Atomic Thread Pool: 4.755237 seconds
+```
+
+</details>
+
+<details>
+
+<summary>AtomicCountDownLatch</summary>
+
+<br>
+
+```ruby
+# frozen_string_literal: true
+
+require "benchmark"
+require "concurrent-ruby"
+require_relative "../lib/atomic-ruby"
+
+results = []
+
+2.times do |idx|
+  result = Benchmark.measure do
+    latch = case idx
+    when 0 then Concurrent::CountDownLatch.new(1)
+    when 1 then AtomicCountDownLatch.new(1)
+    end
+
+    thread = Thread.new do
+      sleep(2)
+      latch.count_down
+    end
+
+    latch.wait
+    thread.join
+  end
+
+  results << result
+end
+
+puts "\n"
+puts "ruby version:            #{RUBY_DESCRIPTION}"
+puts "concurrent-ruby version: #{Concurrent::VERSION}"
+puts "atomic-ruby version:     #{AtomicRuby::VERSION}"
+puts "\n"
+puts "Benchmark Results:"
+puts "Concurrent Ruby Count Down Latch:    #{results[0].total.round(6)} CPU seconds, #{results[0].real.round(6)} elapsed seconds"
+puts "Atomic Ruby Atomic Count Down Latch: #{results[1].total.round(6)} CPU seconds, #{results[1].real.round(6)} elapsed seconds"
+```
+
+```
+> bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_count_down_latch_benchmark.rb
+
+ruby version:            ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
+concurrent-ruby version: 1.3.8
+atomic-ruby version:     0.15.3
 
 Benchmark Results:
-Concurrent Ruby Thread Pool:    5.079561 seconds
-Atomic Ruby Atomic Thread Pool: 4.99168 seconds
+Concurrent Ruby Count Down Latch:    0.000511 CPU seconds, 2.001465 elapsed seconds
+Atomic Ruby Atomic Count Down Latch: 0.023529 CPU seconds, 2.00364 elapsed seconds
 ```
 
 </details>

data/ext/atomic_ruby/atomic_ruby.c

@@ -172,6 +172,7 @@ typedef struct {
   volatile VALUE head;
   volatile VALUE tail;
   volatile rb_atomic_t count;
+  bool closed;
 } atomic_ruby_queue_t;
 
 static void atomic_ruby_queue_mark(void *ptr) {
@@ -211,6 +212,7 @@ static VALUE rb_cAtomicQueue_allocate(VALUE klass) {
   RB_OBJ_WRITE(obj, &atomic_ruby_queue->head, Qnil);
   RB_OBJ_WRITE(obj, &atomic_ruby_queue->tail, Qnil);
   atomic_ruby_queue->count = 0;
+  atomic_ruby_queue->closed = false;
   return obj;
 }
 
@@ -228,6 +230,7 @@ static VALUE rb_cAtomicQueue_initialize(VALUE self) {
 static VALUE rb_cAtomicQueue_push(VALUE self, VALUE value) {
   atomic_ruby_queue_t *atomic_ruby_queue;
   TypedData_Get_Struct(self, atomic_ruby_queue_t, &atomic_ruby_queue_type, atomic_ruby_queue);
+  if (atomic_ruby_queue->closed) return Qfalse;
 
   VALUE new_node = atomic_ruby_queue_node_new(value, Qnil);
 
@@ -259,6 +262,13 @@ static VALUE rb_cAtomicQueue_push(VALUE self, VALUE value) {
   return self;
 }
 
+static VALUE rb_cAtomicQueue_close(VALUE self) {
+  atomic_ruby_queue_t *atomic_ruby_queue;
+  TypedData_Get_Struct(self, atomic_ruby_queue_t, &atomic_ruby_queue_type, atomic_ruby_queue);
+  atomic_ruby_queue->closed = true;
+  return Qnil;
+}
+
 static VALUE rb_cAtomicQueue_pop(VALUE self) {
   atomic_ruby_queue_t *atomic_ruby_queue;
   TypedData_Get_Struct(self, atomic_ruby_queue_t, &atomic_ruby_queue_type, atomic_ruby_queue);
@@ -536,6 +546,7 @@ typedef struct {
   _Atomic unsigned long long waiting_time;
   _Atomic unsigned long long blocked_time;
   _Atomic unsigned long long running_cpu_time;
+  bool active;
 } atomic_ruby_thread_pool_monitor_t;
 
 typedef struct {
@@ -546,8 +557,27 @@ typedef struct {
 } atomic_ruby_thread_pool_worker_state_t;
 
 static rb_internal_thread_specific_key_t atomic_ruby_thread_pool_worker_key;
+static rb_nativethread_lock_t atomic_ruby_thread_pool_monitor_lock;
+static unsigned int atomic_ruby_thread_pool_monitor_count;
+static rb_internal_thread_event_hook_t *atomic_ruby_thread_pool_event_hook;
+
+static void atomic_ruby_thread_pool_event_callback(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *user_data);
+
+static void atomic_ruby_thread_pool_monitor_stop(atomic_ruby_thread_pool_monitor_t *monitor) {
+  rb_nativethread_lock_lock(&atomic_ruby_thread_pool_monitor_lock);
+  if (monitor->active) {
+    monitor->active = false;
+    atomic_ruby_thread_pool_monitor_count--;
+    if (atomic_ruby_thread_pool_monitor_count == 0) {
+      rb_internal_thread_remove_event_hook(atomic_ruby_thread_pool_event_hook);
+      atomic_ruby_thread_pool_event_hook = NULL;
+    }
+  }
+  rb_nativethread_lock_unlock(&atomic_ruby_thread_pool_monitor_lock);
+}
 
 static void atomic_ruby_thread_pool_monitor_free(void *ptr) {
+  atomic_ruby_thread_pool_monitor_stop(ptr);
   xfree(ptr);
 }
 
@@ -655,9 +685,37 @@ static VALUE rb_cThreadPoolMonitor_allocate(VALUE klass) {
   atomic_init(&monitor->waiting_time, 0);
   atomic_init(&monitor->blocked_time, 0);
   atomic_init(&monitor->running_cpu_time, 0);
+  monitor->active = false;
   return obj;
 }
 
+static VALUE rb_cThreadPoolMonitor_start(VALUE self) {
+  atomic_ruby_thread_pool_monitor_t *monitor;
+  TypedData_Get_Struct(self, atomic_ruby_thread_pool_monitor_t, &atomic_ruby_thread_pool_monitor_type, monitor);
+  rb_nativethread_lock_lock(&atomic_ruby_thread_pool_monitor_lock);
+  if (!monitor->active) {
+    monitor->active = true;
+    if (atomic_ruby_thread_pool_monitor_count++ == 0) {
+      atomic_ruby_thread_pool_event_hook = rb_internal_thread_add_event_hook(
+        atomic_ruby_thread_pool_event_callback,
+        RUBY_INTERNAL_THREAD_EVENT_READY |
+          RUBY_INTERNAL_THREAD_EVENT_RESUMED |
+          RUBY_INTERNAL_THREAD_EVENT_SUSPENDED,
+        NULL
+      );
+    }
+  }
+  rb_nativethread_lock_unlock(&atomic_ruby_thread_pool_monitor_lock);
+  return Qnil;
+}
+
+static VALUE rb_cThreadPoolMonitor_stop(VALUE self) {
+  atomic_ruby_thread_pool_monitor_t *monitor;
+  TypedData_Get_Struct(self, atomic_ruby_thread_pool_monitor_t, &atomic_ruby_thread_pool_monitor_type, monitor);
+  atomic_ruby_thread_pool_monitor_stop(monitor);
+  return Qnil;
+}
+
 static VALUE rb_cThreadPoolMonitor_register_worker(VALUE self) {
   atomic_ruby_thread_pool_monitor_t *monitor;
   TypedData_Get_Struct(self, atomic_ruby_thread_pool_monitor_t, &atomic_ruby_thread_pool_monitor_type, monitor);
@@ -739,6 +797,7 @@ RUBY_FUNC_EXPORTED void Init_atomic_ruby(void) {
   rb_define_alloc_func(rb_cAtomicQueue, rb_cAtomicQueue_allocate);
   rb_define_private_method(rb_cAtomicQueue, "_initialize", rb_cAtomicQueue_initialize, 0);
   rb_define_private_method(rb_cAtomicQueue, "_push", rb_cAtomicQueue_push, 1);
+  rb_define_private_method(rb_cAtomicQueue, "_close", rb_cAtomicQueue_close, 0);
   rb_define_private_method(rb_cAtomicQueue, "_pop", rb_cAtomicQueue_pop, 0);
   rb_define_private_method(rb_cAtomicQueue, "_size", rb_cAtomicQueue_size, 0);
   rb_define_private_method(rb_cAtomicQueue, "_empty_p", rb_cAtomicQueue_empty_p, 0);
@@ -756,15 +815,13 @@ RUBY_FUNC_EXPORTED void Init_atomic_ruby(void) {
   rb_define_private_method(rb_cAtomicConditionVariable, "_waiter_count", rb_cAtomicConditionVariable_waiter_count, 0);
 
   atomic_ruby_thread_pool_worker_key = rb_internal_thread_specific_key_create();
-  rb_internal_thread_add_event_hook(
-    atomic_ruby_thread_pool_event_callback,
-    RUBY_INTERNAL_THREAD_EVENT_READY |
-      RUBY_INTERNAL_THREAD_EVENT_RESUMED |
-      RUBY_INTERNAL_THREAD_EVENT_SUSPENDED,
-    NULL
-  );
+  rb_nativethread_lock_initialize(&atomic_ruby_thread_pool_monitor_lock);
+  atomic_ruby_thread_pool_monitor_count = 0;
+  atomic_ruby_thread_pool_event_hook = NULL;
   VALUE rb_cThreadPoolMonitor = rb_define_class_under(rb_mAtomicRuby, "ThreadPoolMonitor", rb_cObject);
   rb_define_alloc_func(rb_cThreadPoolMonitor, rb_cThreadPoolMonitor_allocate);
+  rb_define_method(rb_cThreadPoolMonitor, "start", rb_cThreadPoolMonitor_start, 0);
+  rb_define_method(rb_cThreadPoolMonitor, "stop", rb_cThreadPoolMonitor_stop, 0);
   rb_define_method(rb_cThreadPoolMonitor, "register_worker", rb_cThreadPoolMonitor_register_worker, 0);
   rb_define_method(rb_cThreadPoolMonitor, "unregister_worker", rb_cThreadPoolMonitor_unregister_worker, 0);
   rb_define_method(rb_cThreadPoolMonitor, "start_work", rb_cThreadPoolMonitor_start_work, 0);

data/ext/atomic_ruby/atomic_ruby.h

@@ -4,6 +4,7 @@
 #include "ruby.h"
 #include "ruby/atomic.h"
 #include "ruby/thread.h"
+#include "ruby/thread_native.h"
 #include "ruby/version.h"
 
 #include <stdatomic.h>

data/lib/atomic-ruby/atomic_condition_variable.rb

@@ -8,19 +8,10 @@ module AtomicRuby
   #
   # AtomicConditionVariable lets one or more threads park until another
   # thread signals them, without the paired `Mutex` that Ruby's
-  # `ConditionVariable` requires. The set of parked threads is tracked
-  # in a native doubly-linked list, so registering a waiter, removing a
-  # waiter, and shifting the head off for a signal are all O(1) and
-  # allocation-light. Parking still uses `Thread.stop` and
-  # `Thread#wakeup`, which are the standard kernel-level primitives Ruby
-  # exposes for sleeping a thread.
+  # `ConditionVariable` requires.
   #
-  # The lost-wakeup race in a naive `check-then-park` consumer is avoided
-  # by the {#wait} contract: a waiter registers itself before re-evaluating
-  # the predicate, so any signal that fires after the producer makes the
-  # predicate true is guaranteed to see the waiter and wake it. Ruby also
-  # remembers pending wakeups across `Thread.stop`, so a wakeup that
-  # arrives between the predicate check and the actual park is not lost.
+  # Waiters supply a predicate that is checked again after registration,
+  # preventing signals sent after a relevant state change from being lost.
   #
   # @example Basic usage
   #   condvar = AtomicConditionVariable.new
@@ -72,10 +63,6 @@ module AtomicRuby
 
     # Wakes one parked waiter, or no-ops if none are parked.
     #
-    # If a waiter has registered itself but is not yet inside `Thread.stop`,
-    # Ruby remembers the wakeup and the next `Thread.stop` returns
-    # immediately.
-    #
     # @return [true, false] true if a waiter was signalled, false otherwise
     #
     # @example
@@ -93,8 +80,6 @@ module AtomicRuby
 
     # Wakes every parked waiter.
     #
-    # Each woken thread observes the wake the same way as with {#signal}.
-    #
     # @return [Integer] The number of waiters signalled
     #
     # @example
@@ -111,12 +96,10 @@ module AtomicRuby
     # Blocks until the given block returns a truthy value, then returns that
     # value.
     #
-    # The block is evaluated optimistically first. If it returns truthy on
-    # that pass, no waiter is registered and the call returns immediately.
-    # Otherwise the calling thread registers itself, re-evaluates the
-    # block, and parks via `Thread.stop` until a {#signal} or {#broadcast}
-    # wakes it. The block may run more than once and may run concurrently
-    # with a signalling thread.
+    # The block may run more than once and may run concurrently with a
+    # signalling thread. Rechecking it after registration prevents lost
+    # wakeups. Interrupted waits are unregistered before the exception is
+    # propagated.
     #
     # @yieldreturn [untyped] Truthy to wake, falsy to keep waiting
     # @return [untyped] The first truthy value returned by the block
@@ -140,15 +123,19 @@ module AtomicRuby
 
       self_thread = Thread.current
       loop do
-        waiter = _add_waiter(self_thread)
-        result = yield
-        if result
-          _remove_waiter(waiter)
-          return result
-        end
+        Thread.handle_interrupt(Exception => :never) do
+          waiter = _add_waiter(self_thread)
+          begin
+            Thread.handle_interrupt(Exception => :immediate) do
+              result = yield
+              return result if result
 
-        Thread.stop
-        _remove_waiter(waiter)
+              Thread.stop
+            end
+          ensure
+            _remove_waiter(waiter)
+          end
+        end
       end
     end
   end

data/lib/atomic-ruby/atomic_count_down_latch.rb

@@ -133,10 +133,6 @@ module AtomicRuby
 
     # Blocks the current thread until the count reaches zero.
     #
-    # This method will block the calling thread until other threads have
-    # called {#count_down} enough times to reduce the count to zero.
-    # The method uses busy-waiting (Thread.pass) to check the count.
-    #
     # @return [void]
     #
     # @example Simple wait
@@ -166,7 +162,7 @@ module AtomicRuby
     #
     # @rbs () -> void
     def wait
-      Thread.pass while @count.value > 0
+      sleep 0.001 while @count.value > 0
     end
   end
 end

data/lib/atomic-ruby/atomic_thread_pool.rb

@@ -125,6 +125,7 @@ module AtomicRuby
         @autoscale_available = AtomicConditionVariable.new
         @trim_requested = AtomicBoolean.new(false)
         @thread_pool_monitor = ThreadPoolMonitor.new
+        @thread_pool_monitor.start
       end
 
       start
@@ -154,12 +155,13 @@ module AtomicRuby
     #
     # @rbs (Proc work) -> void
     def <<(work)
-      raise EnqueuedWorkAfterShutdownError if @shutdown.true?
+      Thread.handle_interrupt(Exception => :never) do
+        @trim_requested&.make_false
+        raise EnqueuedWorkAfterShutdownError unless @queue.push(work)
 
-      @trim_requested&.make_false
-      @queue.push(work)
-      @work_available.signal
-      @autoscale_available&.signal
+        @work_available.signal
+        @autoscale_available&.signal
+      end
     end
 
     # Returns the number of currently alive worker threads.
@@ -241,6 +243,9 @@ module AtomicRuby
     # 2. Waits for all currently queued work to complete
     # 3. Waits for all worker threads to terminate
     #
+    # Enqueues accepted before shutdown are processed before the workers
+    # terminate.
+    #
     # After shutdown, all worker threads will be terminated and the pool
     # cannot be restarted. Attempting to enqueue work after shutdown
     # will raise an exception.
@@ -257,13 +262,15 @@ module AtomicRuby
     #
     # @rbs () -> void
     def shutdown
-      return if @shutdown.true?
-
-      @shutdown.make_true
-      @autoscale_available&.broadcast
-      @work_available.broadcast
+      Thread.handle_interrupt(Exception => :never) do
+        @queue.send(:_close)
+        @shutdown.make_true
+        @autoscale_available&.broadcast
+        @work_available.broadcast
+      end
       @autoscaler&.join
       @threads.each(&:join)
+      @thread_pool_monitor&.stop
     end
 
     private

data/lib/atomic-ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AtomicRuby
-  VERSION = "0.15.1"
+  VERSION = "0.15.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 0.15.3
 platform: ruby
 authors:
 - Joshua Young