atomic-ruby 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0171c5fec65586e1a6b090b65e266a8c4fa88c5a3fa7c98e6c41c5fd63654f31
-  data.tar.gz: aa26033345014a3d64ff81faa7ac812fc3de3d4189f9c59d0f559684429d7540
+  metadata.gz: 5a0461b3ac6fd6dbc7674cf028f8fb3727cad76da32ad2c6054a92a2818fe25f
+  data.tar.gz: 6f20eabbb25f29f6c43c166cbe240c1ddf2a6def437317c392a53fe86699a6b8
 SHA512:
-  metadata.gz: 226c50dd465ec5f255f6b5a2991e64939bcdf77d08ecdda4f9c6aea8ee68de16cdb46ac2be7b6705417b316a40a4c4159cf21b4eef34759f0bc939a544930f50
-  data.tar.gz: 4e80ac5fc97aed98950779897c5308d5d3f8180424cca09e4af611d980570b67b3305a1bc0557f8d4278a6b618f7c3ee69d2a60935764e5f59f7769f04711967
+  metadata.gz: 8e29e25f0790c2c3f3417efae11440a5f0500e0e943ce4c4a903f7fc4180342e832319cfe82712284449c876c70aa29ea22899480668bb1f35cc02c9369f8a6c
+  data.tar.gz: f26bc0f694a0e00cc84c9988761a1cf56c50c89d499bd70eb88b3fb896749ba36465d53d16e03d5ad636c8e8cd59b5b1f179bca827cd85c9a59397951bcd6013

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.14.0] - 2026-08-15
+
+- Replace the `AtomicConditionVariable` waiter list with a native doubly-linked list
+- Replace the two-stack queue in `AtomicThreadPool` with `AtomicQueue`
+- Add `AtomicQueue`
+
+## [0.13.0] - 2026-06-12
+
+- Replace `sleep` with `AtomicConditionVariable` in idle `AtomicThreadPool` workers
+- Add `AtomicConditionVariable`
+
 ## [0.12.0] - 2026-05-18
 
 - Wake idle `AtomicThreadPool` workers on enqueue

data/README.md

@@ -49,6 +49,48 @@ atom.toggle
 p atom.false? #=> true
 ```
 
+`AtomicConditionVariable`:
+
+```ruby
+require "atomic-ruby"
+
+condvar = AtomicConditionVariable.new
+ready = AtomicBoolean.new(false)
+p condvar.waiter_count #=> 0
+
+waiter = Thread.new do
+  condvar.wait { ready.true? }
+end
+Thread.pass until condvar.waiter_count == 1
+p condvar.waiter_count #=> 1
+
+ready.make_true
+p condvar.signal       #=> true
+waiter.join
+p condvar.waiter_count #=> 0
+```
+
+`AtomicQueue`:
+
+```ruby
+require "atomic-ruby"
+
+queue = AtomicQueue.new
+p queue.empty? #=> true
+p queue.size   #=> 0
+
+queue.push(1)
+queue << 2
+queue << 3
+p queue.size   #=> 3
+
+p queue.pop    #=> 1
+p queue.pop    #=> 2
+p queue.pop    #=> 3
+p queue.pop    #=> nil
+p queue.empty? #=> true
+```
+
 `AtomicThreadPool`:
 
 ```ruby
@@ -98,7 +140,9 @@ p latch.count #=> 0
 ```
 
 > [!NOTE]
-> `Atom`, `AtomicBoolean`, and `AtomicCountDownLatch` are Ractor-safe in Ruby 4.0+.
+> `Atom`, `AtomicBoolean`, and `AtomicCountDownLatch` are Ractor-safe in Ruby 4.0+. `AtomicConditionVariable` and
+> `AtomicQueue` are not, since they hold mutable references (parked `Thread`s and queued values, respectively) which
+> cannot be shared across ractors.
 
 ## Benchmarks
 
@@ -208,11 +252,11 @@ puts "Atomic Ruby Atomic Bank Account:     #{results[2].real.round(6)} seconds"
 ```
 
 ```
-> bundle exec rake compile && bundle exec ruby examples/atom_benchmark.rb
+> bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atom_benchmark.rb
 
-ruby version:            ruby 4.0.3 (2026-04-21 revision 85ddef263a) +YJIT +PRISM [arm64-darwin23]
+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.11.0
+atomic-ruby version:     0.14.0
 
 Balances:
 Synchronized Bank Account Balance:           975
@@ -220,9 +264,9 @@ Concurrent Ruby Atomic Bank Account Balance: 975
 Atomic Ruby Atomic Bank Account Balance:     975
 
 Benchmark Results:
-Synchronized Bank Account:           5.106931 seconds
-Concurrent Ruby Atomic Bank Account: 5.106199 seconds
-Atomic Ruby Atomic Bank Account:     5.101662 seconds
+Synchronized Bank Account:           5.117072 seconds
+Concurrent Ruby Atomic Bank Account: 5.128366 seconds
+Atomic Ruby Atomic Bank Account:     5.110595 seconds
 ```
 
 </details>
@@ -299,31 +343,181 @@ end
 ```
 
 ```
-> bundle exec rake compile && bundle exec ruby examples/atomic_boolean_benchmark.rb
+> bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_boolean_benchmark.rb
 
-ruby version:            ruby 4.0.3 (2026-04-21 revision 85ddef263a) +YJIT +PRISM [arm64-darwin23]
+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.11.0
+atomic-ruby version:     0.14.0
+
+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
+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
+
+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
+```
+
+</details>
+
+<details>
+
+<summary>AtomicConditionVariable</summary>
+
+```ruby
+# frozen_string_literal: true
+
+require "benchmark/ips"
+require_relative "../lib/atomic-ruby"
+
+module Benchmark
+  module IPS
+    class Job
+      class StreamReport
+        def start_warming
+          @out.puts "\n"
+          @out.puts "ruby version:        #{RUBY_DESCRIPTION}"
+          @out.puts "atomic-ruby version: #{AtomicRuby::VERSION}"
+          @out.puts "\n"
+          @out.puts "Warming up --------------------------------------"
+        end
+      end
+    end
+  end
+end
+
+Benchmark.ips do |x|
+  x.report("Synchronized Condition Variable Wait/Signal") do
+    flag = false
+    mutex = Mutex.new
+    condvar = ConditionVariable.new
+
+    waiter = Thread.new do
+      mutex.synchronize do
+        condvar.wait(mutex) until flag
+      end
+    end
+
+    mutex.synchronize do
+      flag = true
+      condvar.signal
+    end
+    waiter.join
+  end
+
+  x.report("Atomic Ruby Atomic Condition Variable Wait/Signal") do
+    flag = AtomicBoolean.new(false)
+    condvar = AtomicConditionVariable.new
+
+    waiter = Thread.new { condvar.wait { flag.true? } }
+
+    flag.make_true
+    condvar.signal
+    waiter.join
+  end
+
+  x.compare!
+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.14.0
 
 Warming up --------------------------------------
-Synchronized Boolean Toggle
-                       135.000 i/100ms
-Concurrent Ruby Atomic Boolean Toggle
-                       117.000 i/100ms
-Atomic Ruby Atomic Boolean Toggle
-                       101.000 i/100ms
+      Synchronized Condition Variable Wait/Signal     3.977k i/100ms
+Atomic Ruby Atomic Condition Variable Wait/Signal     3.885k i/100ms
 Calculating -------------------------------------
-Synchronized Boolean Toggle
-                          1.414k (± 1.4%) i/s  (707.15 μs/i) -      7.155k in   5.060692s
-Concurrent Ruby Atomic Boolean Toggle
-                          1.149k (± 2.9%) i/s  (870.53 μs/i) -      5.850k in   5.097019s
-Atomic Ruby Atomic Boolean Toggle
-                          1.046k (± 2.1%) i/s  (955.57 μs/i) -      5.252k in   5.021118s
+      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
 
 Comparison:
-Synchronized Boolean Toggle:               1414.1 i/s
-Concurrent Ruby Atomic Boolean Toggle:     1148.7 i/s - 1.23x  slower
-Atomic Ruby Atomic Boolean Toggle:         1046.5 i/s - 1.35x  slower
+      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
+```
+
+</details>
+
+<details>
+
+<summary>AtomicQueue</summary>
+
+```ruby
+# frozen_string_literal: true
+
+require "benchmark/ips"
+require_relative "../lib/atomic-ruby"
+
+module Benchmark
+  module IPS
+    class Job
+      class StreamReport
+        def start_warming
+          @out.puts "\n"
+          @out.puts "ruby version:        #{RUBY_DESCRIPTION}"
+          @out.puts "atomic-ruby version: #{AtomicRuby::VERSION}"
+          @out.puts "\n"
+          @out.puts "Warming up --------------------------------------"
+        end
+      end
+    end
+  end
+end
+
+Benchmark.ips do |x|
+  x.report("Synchronized Queue Push/Pop") do
+    queue = Thread::Queue.new
+    20.times.map do
+      Thread.new do
+        100.times do |i|
+          queue.push(i)
+          queue.pop(true) rescue nil
+        end
+      end
+    end.each(&:join)
+  end
+
+  x.report("Atomic Ruby Atomic Queue Push/Pop") do
+    queue = AtomicQueue.new
+    20.times.map do
+      Thread.new do
+        100.times do |i|
+          queue.push(i)
+          queue.pop
+        end
+      end
+    end.each(&:join)
+  end
+
+  x.compare!
+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.14.0
+
+Warming up --------------------------------------
+      Synchronized Queue Push/Pop   181.000 i/100ms
+Atomic Ruby Atomic Queue Push/Pop   132.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
+
+Comparison:
+      Synchronized Queue Push/Pop:     1845.3 i/s
+Atomic Ruby Atomic Queue Push/Pop:     1431.3 i/s - 1.29x  slower
+
 ```
 
 </details>
@@ -377,15 +571,15 @@ puts "Atomic Ruby Atomic Thread Pool: #{results[1].real.round(6)} seconds"
 ```
 
 ```
-> bundle exec rake compile && bundle exec ruby examples/atomic_thread_pool_benchmark.rb
+> bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_thread_pool_benchmark.rb
 
-ruby version:            ruby 4.0.4 (2026-05-12 revision b89eb1bcbf) +YJIT +PRISM [arm64-darwin23]
+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.12.0
+atomic-ruby version:     0.14.0
 
 Benchmark Results:
-Concurrent Ruby Thread Pool:    5.987538 seconds
-Atomic Ruby Atomic Thread Pool: 5.528936 seconds
+Concurrent Ruby Thread Pool:    5.078227 seconds
+Atomic Ruby Atomic Thread Pool: 4.824681 seconds
 ```
 
 </details>

data/ext/atomic_ruby/atomic_ruby.c

@@ -122,6 +122,405 @@ static VALUE rb_cAtom_initialized_ractor(VALUE self) {
 }
 #endif
 
+typedef struct {
+  volatile VALUE value;
+  volatile VALUE next;
+} atomic_ruby_queue_node_t;
+
+static void atomic_ruby_queue_node_mark(void *ptr) {
+  atomic_ruby_queue_node_t *atomic_ruby_queue_node = (atomic_ruby_queue_node_t *)ptr;
+  rb_gc_mark_movable(atomic_ruby_queue_node->value);
+  rb_gc_mark_movable(atomic_ruby_queue_node->next);
+}
+
+static void atomic_ruby_queue_node_free(void *ptr) {
+  xfree(ptr);
+}
+
+static size_t atomic_ruby_queue_node_memsize(const void *ptr) {
+  return sizeof(atomic_ruby_queue_node_t);
+}
+
+static void atomic_ruby_queue_node_compact(void *ptr) {
+  atomic_ruby_queue_node_t *atomic_ruby_queue_node = (atomic_ruby_queue_node_t *)ptr;
+  atomic_ruby_queue_node->value = rb_gc_location(atomic_ruby_queue_node->value);
+  atomic_ruby_queue_node->next = rb_gc_location(atomic_ruby_queue_node->next);
+}
+
+static const rb_data_type_t atomic_ruby_queue_node_type = {
+  .wrap_struct_name = "AtomicRuby::AtomicQueue::Node",
+  .function = {
+    .dmark = atomic_ruby_queue_node_mark,
+    .dfree = atomic_ruby_queue_node_free,
+    .dsize = atomic_ruby_queue_node_memsize,
+    .dcompact = atomic_ruby_queue_node_compact
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE rb_cAtomicQueueNode;
+
+static VALUE atomic_ruby_queue_node_new(VALUE value, VALUE next) {
+  atomic_ruby_queue_node_t *atomic_ruby_queue_node;
+  VALUE obj = TypedData_Make_Struct(rb_cAtomicQueueNode, atomic_ruby_queue_node_t, &atomic_ruby_queue_node_type, atomic_ruby_queue_node);
+  RB_OBJ_WRITE(obj, &atomic_ruby_queue_node->value, value);
+  RB_OBJ_WRITE(obj, &atomic_ruby_queue_node->next, next);
+  return obj;
+}
+
+typedef struct {
+  volatile VALUE head;
+  volatile VALUE tail;
+  volatile rb_atomic_t count;
+} atomic_ruby_queue_t;
+
+static void atomic_ruby_queue_mark(void *ptr) {
+  atomic_ruby_queue_t *atomic_ruby_queue = (atomic_ruby_queue_t *)ptr;
+  rb_gc_mark_movable(atomic_ruby_queue->head);
+  rb_gc_mark_movable(atomic_ruby_queue->tail);
+}
+
+static void atomic_ruby_queue_free(void *ptr) {
+  xfree(ptr);
+}
+
+static size_t atomic_ruby_queue_memsize(const void *ptr) {
+  return sizeof(atomic_ruby_queue_t);
+}
+
+static void atomic_ruby_queue_compact(void *ptr) {
+  atomic_ruby_queue_t *atomic_ruby_queue = (atomic_ruby_queue_t *)ptr;
+  atomic_ruby_queue->head = rb_gc_location(atomic_ruby_queue->head);
+  atomic_ruby_queue->tail = rb_gc_location(atomic_ruby_queue->tail);
+}
+
+static const rb_data_type_t atomic_ruby_queue_type = {
+  .wrap_struct_name = "AtomicRuby::AtomicQueue",
+  .function = {
+    .dmark = atomic_ruby_queue_mark,
+    .dfree = atomic_ruby_queue_free,
+    .dsize = atomic_ruby_queue_memsize,
+    .dcompact = atomic_ruby_queue_compact
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE rb_cAtomicQueue_allocate(VALUE klass) {
+  atomic_ruby_queue_t *atomic_ruby_queue;
+  VALUE obj = TypedData_Make_Struct(klass, atomic_ruby_queue_t, &atomic_ruby_queue_type, atomic_ruby_queue);
+  RB_OBJ_WRITE(obj, &atomic_ruby_queue->head, Qnil);
+  RB_OBJ_WRITE(obj, &atomic_ruby_queue->tail, Qnil);
+  atomic_ruby_queue->count = 0;
+  return obj;
+}
+
+static VALUE rb_cAtomicQueue_initialize(VALUE self) {
+  atomic_ruby_queue_t *atomic_ruby_queue;
+  TypedData_Get_Struct(self, atomic_ruby_queue_t, &atomic_ruby_queue_type, atomic_ruby_queue);
+
+  VALUE sentinel = atomic_ruby_queue_node_new(Qnil, Qnil);
+  RB_OBJ_WRITE(self, &atomic_ruby_queue->head, sentinel);
+  RB_OBJ_WRITE(self, &atomic_ruby_queue->tail, sentinel);
+
+  return 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);
+
+  VALUE new_node = atomic_ruby_queue_node_new(value, Qnil);
+
+  VALUE tail;
+  while (1) {
+    tail = (VALUE)RUBY_ATOMIC_PTR_LOAD(atomic_ruby_queue->tail);
+    atomic_ruby_queue_node_t *tail_node;
+    TypedData_Get_Struct(tail, atomic_ruby_queue_node_t, &atomic_ruby_queue_node_type, tail_node);
+    VALUE tail_next = (VALUE)RUBY_ATOMIC_PTR_LOAD(tail_node->next);
+
+    if (tail != (VALUE)RUBY_ATOMIC_PTR_LOAD(atomic_ruby_queue->tail)) continue;
+
+    if (tail_next != Qnil) {
+      RUBY_ATOMIC_VALUE_CAS(atomic_ruby_queue->tail, tail, tail_next);
+      RB_OBJ_WRITTEN(self, tail, tail_next);
+      continue;
+    }
+
+    if (RUBY_ATOMIC_VALUE_CAS(tail_node->next, Qnil, new_node) == Qnil) {
+      RB_OBJ_WRITTEN(tail, Qnil, new_node);
+      break;
+    }
+  }
+
+  RUBY_ATOMIC_VALUE_CAS(atomic_ruby_queue->tail, tail, new_node);
+  RB_OBJ_WRITTEN(self, tail, new_node);
+  RUBY_ATOMIC_INC(atomic_ruby_queue->count);
+
+  return self;
+}
+
+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);
+
+  VALUE head, head_next, result;
+  while (1) {
+    head = (VALUE)RUBY_ATOMIC_PTR_LOAD(atomic_ruby_queue->head);
+    VALUE tail = (VALUE)RUBY_ATOMIC_PTR_LOAD(atomic_ruby_queue->tail);
+    atomic_ruby_queue_node_t *head_node;
+    TypedData_Get_Struct(head, atomic_ruby_queue_node_t, &atomic_ruby_queue_node_type, head_node);
+    head_next = (VALUE)RUBY_ATOMIC_PTR_LOAD(head_node->next);
+
+    if (head != (VALUE)RUBY_ATOMIC_PTR_LOAD(atomic_ruby_queue->head)) continue;
+
+    if (head == tail) {
+      if (head_next == Qnil) return Qnil;
+
+      RUBY_ATOMIC_VALUE_CAS(atomic_ruby_queue->tail, tail, head_next);
+      RB_OBJ_WRITTEN(self, tail, head_next);
+      continue;
+    }
+
+    atomic_ruby_queue_node_t *next_node;
+    TypedData_Get_Struct(head_next, atomic_ruby_queue_node_t, &atomic_ruby_queue_node_type, next_node);
+    result = next_node->value;
+
+    if (RUBY_ATOMIC_VALUE_CAS(atomic_ruby_queue->head, head, head_next) == head) {
+      RB_OBJ_WRITTEN(self, head, head_next);
+      break;
+    }
+  }
+
+  RUBY_ATOMIC_DEC(atomic_ruby_queue->count);
+  return result;
+}
+
+static VALUE rb_cAtomicQueue_size(VALUE self) {
+  atomic_ruby_queue_t *atomic_ruby_queue;
+  TypedData_Get_Struct(self, atomic_ruby_queue_t, &atomic_ruby_queue_type, atomic_ruby_queue);
+  return UINT2NUM((unsigned int)RUBY_ATOMIC_LOAD(atomic_ruby_queue->count));
+}
+
+static VALUE rb_cAtomicQueue_empty_p(VALUE self) {
+  atomic_ruby_queue_t *atomic_ruby_queue;
+  TypedData_Get_Struct(self, atomic_ruby_queue_t, &atomic_ruby_queue_type, atomic_ruby_queue);
+  return RUBY_ATOMIC_LOAD(atomic_ruby_queue->count) == 0 ? Qtrue : Qfalse;
+}
+
+typedef struct {
+  volatile VALUE prev;
+  volatile VALUE next;
+  volatile VALUE thread;
+} atomic_ruby_condition_variable_waiter_t;
+
+static void atomic_ruby_condition_variable_waiter_mark(void *ptr) {
+  atomic_ruby_condition_variable_waiter_t *atomic_ruby_condition_variable_waiter = (atomic_ruby_condition_variable_waiter_t *)ptr;
+  rb_gc_mark_movable(atomic_ruby_condition_variable_waiter->prev);
+  rb_gc_mark_movable(atomic_ruby_condition_variable_waiter->next);
+  rb_gc_mark_movable(atomic_ruby_condition_variable_waiter->thread);
+}
+
+static void atomic_ruby_condition_variable_waiter_free(void *ptr) {
+  xfree(ptr);
+}
+
+static size_t atomic_ruby_condition_variable_waiter_memsize(const void *ptr) {
+  return sizeof(atomic_ruby_condition_variable_waiter_t);
+}
+
+static void atomic_ruby_condition_variable_waiter_compact(void *ptr) {
+  atomic_ruby_condition_variable_waiter_t *atomic_ruby_condition_variable_waiter = (atomic_ruby_condition_variable_waiter_t *)ptr;
+  atomic_ruby_condition_variable_waiter->prev = rb_gc_location(atomic_ruby_condition_variable_waiter->prev);
+  atomic_ruby_condition_variable_waiter->next = rb_gc_location(atomic_ruby_condition_variable_waiter->next);
+  atomic_ruby_condition_variable_waiter->thread = rb_gc_location(atomic_ruby_condition_variable_waiter->thread);
+}
+
+static const rb_data_type_t atomic_ruby_condition_variable_waiter_type = {
+  .wrap_struct_name = "AtomicRuby::AtomicConditionVariable::Waiter",
+  .function = {
+    .dmark = atomic_ruby_condition_variable_waiter_mark,
+    .dfree = atomic_ruby_condition_variable_waiter_free,
+    .dsize = atomic_ruby_condition_variable_waiter_memsize,
+    .dcompact = atomic_ruby_condition_variable_waiter_compact
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE rb_cAtomicConditionVariableWaiter;
+
+static VALUE atomic_ruby_condition_variable_waiter_new(VALUE thread) {
+  atomic_ruby_condition_variable_waiter_t *atomic_ruby_condition_variable_waiter;
+  VALUE obj = TypedData_Make_Struct(rb_cAtomicConditionVariableWaiter, atomic_ruby_condition_variable_waiter_t, &atomic_ruby_condition_variable_waiter_type, atomic_ruby_condition_variable_waiter);
+  RB_OBJ_WRITE(obj, &atomic_ruby_condition_variable_waiter->prev, Qnil);
+  RB_OBJ_WRITE(obj, &atomic_ruby_condition_variable_waiter->next, Qnil);
+  RB_OBJ_WRITE(obj, &atomic_ruby_condition_variable_waiter->thread, thread);
+  return obj;
+}
+
+typedef struct {
+  volatile VALUE head;
+  volatile VALUE tail;
+  volatile rb_atomic_t count;
+} atomic_ruby_condition_variable_t;
+
+static void atomic_ruby_condition_variable_mark(void *ptr) {
+  atomic_ruby_condition_variable_t *atomic_ruby_condition_variable = (atomic_ruby_condition_variable_t *)ptr;
+  rb_gc_mark_movable(atomic_ruby_condition_variable->head);
+  rb_gc_mark_movable(atomic_ruby_condition_variable->tail);
+}
+
+static void atomic_ruby_condition_variable_free(void *ptr) {
+  xfree(ptr);
+}
+
+static size_t atomic_ruby_condition_variable_memsize(const void *ptr) {
+  return sizeof(atomic_ruby_condition_variable_t);
+}
+
+static void atomic_ruby_condition_variable_compact(void *ptr) {
+  atomic_ruby_condition_variable_t *atomic_ruby_condition_variable = (atomic_ruby_condition_variable_t *)ptr;
+  atomic_ruby_condition_variable->head = rb_gc_location(atomic_ruby_condition_variable->head);
+  atomic_ruby_condition_variable->tail = rb_gc_location(atomic_ruby_condition_variable->tail);
+}
+
+static const rb_data_type_t atomic_ruby_condition_variable_type = {
+  .wrap_struct_name = "AtomicRuby::AtomicConditionVariable",
+  .function = {
+    .dmark = atomic_ruby_condition_variable_mark,
+    .dfree = atomic_ruby_condition_variable_free,
+    .dsize = atomic_ruby_condition_variable_memsize,
+    .dcompact = atomic_ruby_condition_variable_compact
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE rb_cAtomicConditionVariable_allocate(VALUE klass) {
+  atomic_ruby_condition_variable_t *atomic_ruby_condition_variable;
+  VALUE obj = TypedData_Make_Struct(klass, atomic_ruby_condition_variable_t, &atomic_ruby_condition_variable_type, atomic_ruby_condition_variable);
+  RB_OBJ_WRITE(obj, &atomic_ruby_condition_variable->head, Qnil);
+  RB_OBJ_WRITE(obj, &atomic_ruby_condition_variable->tail, Qnil);
+  atomic_ruby_condition_variable->count = 0;
+  return obj;
+}
+
+static VALUE rb_cAtomicConditionVariable_initialize(VALUE self) {
+  return self;
+}
+
+static VALUE rb_cAtomicConditionVariable_add_waiter(VALUE self, VALUE thread) {
+  atomic_ruby_condition_variable_t *atomic_ruby_condition_variable;
+  TypedData_Get_Struct(self, atomic_ruby_condition_variable_t, &atomic_ruby_condition_variable_type, atomic_ruby_condition_variable);
+
+  VALUE new_waiter = atomic_ruby_condition_variable_waiter_new(thread);
+  atomic_ruby_condition_variable_waiter_t *new_waiter_data;
+  TypedData_Get_Struct(new_waiter, atomic_ruby_condition_variable_waiter_t, &atomic_ruby_condition_variable_waiter_type, new_waiter_data);
+
+  VALUE tail = atomic_ruby_condition_variable->tail;
+  if (tail == Qnil) {
+    RB_OBJ_WRITE(self, &atomic_ruby_condition_variable->head, new_waiter);
+    RB_OBJ_WRITE(self, &atomic_ruby_condition_variable->tail, new_waiter);
+  } else {
+    atomic_ruby_condition_variable_waiter_t *tail_data;
+    TypedData_Get_Struct(tail, atomic_ruby_condition_variable_waiter_t, &atomic_ruby_condition_variable_waiter_type, tail_data);
+    RB_OBJ_WRITE(tail, &tail_data->next, new_waiter);
+    RB_OBJ_WRITE(new_waiter, &new_waiter_data->prev, tail);
+    RB_OBJ_WRITE(self, &atomic_ruby_condition_variable->tail, new_waiter);
+  }
+  RUBY_ATOMIC_INC(atomic_ruby_condition_variable->count);
+
+  return new_waiter;
+}
+
+static VALUE rb_cAtomicConditionVariable_remove_waiter(VALUE self, VALUE waiter) {
+  atomic_ruby_condition_variable_t *atomic_ruby_condition_variable;
+  TypedData_Get_Struct(self, atomic_ruby_condition_variable_t, &atomic_ruby_condition_variable_type, atomic_ruby_condition_variable);
+  atomic_ruby_condition_variable_waiter_t *waiter_data;
+  TypedData_Get_Struct(waiter, atomic_ruby_condition_variable_waiter_t, &atomic_ruby_condition_variable_waiter_type, waiter_data);
+
+  VALUE prev = waiter_data->prev;
+  VALUE next = waiter_data->next;
+
+  if (prev == Qnil && next == Qnil && atomic_ruby_condition_variable->head != waiter) return Qnil;
+
+  if (prev == Qnil) {
+    RB_OBJ_WRITE(self, &atomic_ruby_condition_variable->head, next);
+  } else {
+    atomic_ruby_condition_variable_waiter_t *prev_data;
+    TypedData_Get_Struct(prev, atomic_ruby_condition_variable_waiter_t, &atomic_ruby_condition_variable_waiter_type, prev_data);
+    RB_OBJ_WRITE(prev, &prev_data->next, next);
+  }
+
+  if (next == Qnil) {
+    RB_OBJ_WRITE(self, &atomic_ruby_condition_variable->tail, prev);
+  } else {
+    atomic_ruby_condition_variable_waiter_t *next_data;
+    TypedData_Get_Struct(next, atomic_ruby_condition_variable_waiter_t, &atomic_ruby_condition_variable_waiter_type, next_data);
+    RB_OBJ_WRITE(next, &next_data->prev, prev);
+  }
+
+  RB_OBJ_WRITE(waiter, &waiter_data->prev, Qnil);
+  RB_OBJ_WRITE(waiter, &waiter_data->next, Qnil);
+  RUBY_ATOMIC_DEC(atomic_ruby_condition_variable->count);
+
+  return Qnil;
+}
+
+static VALUE rb_cAtomicConditionVariable_shift_thread(VALUE self) {
+  atomic_ruby_condition_variable_t *atomic_ruby_condition_variable;
+  TypedData_Get_Struct(self, atomic_ruby_condition_variable_t, &atomic_ruby_condition_variable_type, atomic_ruby_condition_variable);
+
+  VALUE head = atomic_ruby_condition_variable->head;
+  if (head == Qnil) return Qnil;
+
+  atomic_ruby_condition_variable_waiter_t *head_data;
+  TypedData_Get_Struct(head, atomic_ruby_condition_variable_waiter_t, &atomic_ruby_condition_variable_waiter_type, head_data);
+  VALUE thread = head_data->thread;
+  VALUE next = head_data->next;
+
+  RB_OBJ_WRITE(self, &atomic_ruby_condition_variable->head, next);
+  if (next == Qnil) {
+    RB_OBJ_WRITE(self, &atomic_ruby_condition_variable->tail, Qnil);
+  } else {
+    atomic_ruby_condition_variable_waiter_t *next_data;
+    TypedData_Get_Struct(next, atomic_ruby_condition_variable_waiter_t, &atomic_ruby_condition_variable_waiter_type, next_data);
+    RB_OBJ_WRITE(next, &next_data->prev, Qnil);
+  }
+
+  RB_OBJ_WRITE(head, &head_data->prev, Qnil);
+  RB_OBJ_WRITE(head, &head_data->next, Qnil);
+  RUBY_ATOMIC_DEC(atomic_ruby_condition_variable->count);
+
+  return thread;
+}
+
+static VALUE rb_cAtomicConditionVariable_drain_threads(VALUE self) {
+  atomic_ruby_condition_variable_t *atomic_ruby_condition_variable;
+  TypedData_Get_Struct(self, atomic_ruby_condition_variable_t, &atomic_ruby_condition_variable_type, atomic_ruby_condition_variable);
+
+  VALUE threads = rb_ary_new();
+  VALUE current = atomic_ruby_condition_variable->head;
+  while (current != Qnil) {
+    atomic_ruby_condition_variable_waiter_t *waiter_data;
+    TypedData_Get_Struct(current, atomic_ruby_condition_variable_waiter_t, &atomic_ruby_condition_variable_waiter_type, waiter_data);
+    rb_ary_push(threads, waiter_data->thread);
+    VALUE next = waiter_data->next;
+    RB_OBJ_WRITE(current, &waiter_data->prev, Qnil);
+    RB_OBJ_WRITE(current, &waiter_data->next, Qnil);
+    current = next;
+  }
+  RB_OBJ_WRITE(self, &atomic_ruby_condition_variable->head, Qnil);
+  RB_OBJ_WRITE(self, &atomic_ruby_condition_variable->tail, Qnil);
+  atomic_ruby_condition_variable->count = 0;
+
+  return threads;
+}
+
+static VALUE rb_cAtomicConditionVariable_waiter_count(VALUE self) {
+  atomic_ruby_condition_variable_t *atomic_ruby_condition_variable;
+  TypedData_Get_Struct(self, atomic_ruby_condition_variable_t, &atomic_ruby_condition_variable_type, atomic_ruby_condition_variable);
+  return UINT2NUM((unsigned int)RUBY_ATOMIC_LOAD(atomic_ruby_condition_variable->count));
+}
+
 RUBY_FUNC_EXPORTED void Init_atomic_ruby(void) {
 #ifdef ATOMIC_RUBY_RACTOR_SAFE
   rb_ext_ractor_safe(true);
@@ -141,4 +540,27 @@ RUBY_FUNC_EXPORTED void Init_atomic_ruby(void) {
 #else
   rb_define_const(rb_mAtomicRuby, "RACTOR_SAFE", Qfalse);
 #endif
+
+  VALUE rb_cAtomicQueue = rb_define_class_under(rb_mAtomicRuby, "AtomicQueue", rb_cObject);
+  rb_cAtomicQueueNode = rb_define_class_under(rb_cAtomicQueue, "Node", rb_cObject);
+  rb_undef_alloc_func(rb_cAtomicQueueNode);
+
+  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, "_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);
+
+  VALUE rb_cAtomicConditionVariable = rb_define_class_under(rb_mAtomicRuby, "AtomicConditionVariable", rb_cObject);
+  rb_cAtomicConditionVariableWaiter = rb_define_class_under(rb_cAtomicConditionVariable, "Waiter", rb_cObject);
+  rb_undef_alloc_func(rb_cAtomicConditionVariableWaiter);
+
+  rb_define_alloc_func(rb_cAtomicConditionVariable, rb_cAtomicConditionVariable_allocate);
+  rb_define_private_method(rb_cAtomicConditionVariable, "_initialize", rb_cAtomicConditionVariable_initialize, 0);
+  rb_define_private_method(rb_cAtomicConditionVariable, "_add_waiter", rb_cAtomicConditionVariable_add_waiter, 1);
+  rb_define_private_method(rb_cAtomicConditionVariable, "_remove_waiter", rb_cAtomicConditionVariable_remove_waiter, 1);
+  rb_define_private_method(rb_cAtomicConditionVariable, "_shift_thread", rb_cAtomicConditionVariable_shift_thread, 0);
+  rb_define_private_method(rb_cAtomicConditionVariable, "_drain_threads", rb_cAtomicConditionVariable_drain_threads, 0);
+  rb_define_private_method(rb_cAtomicConditionVariable, "_waiter_count", rb_cAtomicConditionVariable_waiter_count, 0);
 }

data/lib/atomic-ruby/atomic_condition_variable.rb

@@ -0,0 +1,157 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "atomic_ruby/atomic_ruby"
+
+module AtomicRuby
+  # Provides lock-free wait/signal coordination using atomic operations.
+  #
+  # 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.
+  #
+  # 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.
+  #
+  # @example Basic usage
+  #   condvar = AtomicConditionVariable.new
+  #   ready = AtomicBoolean.new(false)
+  #
+  #   waiter = Thread.new do
+  #     condvar.wait { ready.true? }
+  #     puts "ready"
+  #   end
+  #
+  #   ready.make_true
+  #   condvar.signal
+  #
+  # @example Worker loop draining an atomic queue
+  #   condvar.wait do
+  #     work = queue.pop
+  #     work || shutdown.true?
+  #   end
+  #
+  # @note This class is NOT Ractor-safe as it parks `Thread` references,
+  #   which cannot be shared across ractors.
+  class AtomicConditionVariable
+    # Creates a new condition variable with no parked threads.
+    #
+    # @example
+    #   condvar = AtomicConditionVariable.new
+    #
+    # @rbs () -> void
+    def initialize
+      _initialize
+    end
+
+    # Returns the number of currently parked waiters.
+    #
+    # This operation is atomic and thread-safe. The returned value reflects
+    # the state at the time of the call, but may change immediately after
+    # in concurrent environments.
+    #
+    # @return [Integer] The number of currently parked waiters
+    #
+    # @example
+    #   condvar = AtomicConditionVariable.new
+    #   puts condvar.waiter_count #=> 0
+    #
+    # @rbs () -> Integer
+    def waiter_count
+      _waiter_count
+    end
+
+    # 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
+    #   condvar = AtomicConditionVariable.new
+    #   condvar.signal #=> false
+    #
+    # @rbs () -> bool
+    def signal
+      thread = _shift_thread
+      return false unless thread
+
+      thread.wakeup rescue nil
+      true
+    end
+
+    # Wakes every parked waiter.
+    #
+    # Each woken thread observes the wake the same way as with {#signal}.
+    #
+    # @return [Integer] The number of waiters signalled
+    #
+    # @example
+    #   condvar = AtomicConditionVariable.new
+    #   condvar.broadcast #=> 0
+    #
+    # @rbs () -> Integer
+    def broadcast
+      threads = _drain_threads
+      threads.each { |thread| thread.wakeup rescue nil }
+      threads.size
+    end
+
+    # 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.
+    #
+    # @yieldreturn [untyped] Truthy to wake, falsy to keep waiting
+    # @return [untyped] The first truthy value returned by the block
+    #
+    # @example Simple wait
+    #   condvar = AtomicConditionVariable.new
+    #   ready = AtomicBoolean.new(false)
+    #
+    #   Thread.new do
+    #     sleep(1)
+    #     ready.make_true
+    #     condvar.signal
+    #   end
+    #
+    #   condvar.wait { ready.true? } #=> true
+    #
+    # @rbs () { () -> untyped } -> untyped
+    def wait
+      result = yield
+      return result if result
+
+      self_thread = Thread.current
+      loop do
+        waiter = _add_waiter(self_thread)
+        result = yield
+        if result
+          _remove_waiter(waiter)
+          return result
+        end
+
+        Thread.stop
+        _remove_waiter(waiter)
+      end
+    end
+  end
+end
+
+AtomicConditionVariable = AtomicRuby::AtomicConditionVariable

data/lib/atomic-ruby/atomic_queue.rb

@@ -0,0 +1,137 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "atomic_ruby/atomic_ruby"
+
+module AtomicRuby
+  # Provides a lock-free FIFO queue using atomic operations.
+  #
+  # AtomicQueue is a multi-producer, multi-consumer queue backed by a
+  # singly-linked list of nodes with atomic head and tail pointers.
+  # Enqueueing and dequeueing use compare-and-swap operations so
+  # concurrent producers and consumers never block one another.
+  #
+  # The queue is implemented as a Michael-Scott lock-free FIFO with a
+  # dummy sentinel node. Both {#push} and {#pop} are O(1). Nodes are
+  # Ruby-managed values, so the garbage collector reclaims dequeued
+  # nodes once no thread holds a reference to them.
+  #
+  # @example Basic usage
+  #   queue = AtomicQueue.new
+  #   queue.push(1)
+  #   queue.push(2)
+  #   puts queue.pop #=> 1
+  #   puts queue.pop #=> 2
+  #   puts queue.pop #=> nil
+  #
+  # @example Producer/consumer coordination
+  #   queue = AtomicQueue.new
+  #   producers = 4.times.map do
+  #     Thread.new { 100.times { |index| queue.push(index) } }
+  #   end
+  #   producers.each(&:join)
+  #   puts queue.size #=> 400
+  #
+  # @note This class is NOT Ractor-safe as it stores mutable references
+  #   to queued values that cannot be safely shared across ractors.
+  class AtomicQueue
+    # Creates a new empty queue.
+    #
+    # @example
+    #   queue = AtomicQueue.new
+    #
+    # @rbs () -> void
+    def initialize
+      _initialize
+    end
+
+    # Enqueues a value at the tail of the queue.
+    #
+    # This operation is atomic and thread-safe. Multiple threads may
+    # push concurrently without blocking one another.
+    #
+    # @param value [untyped] The value to enqueue
+    # @return [self]
+    #
+    # @example
+    #   queue = AtomicQueue.new
+    #   queue.push(1)
+    #   queue.push("two")
+    #   queue.push(nil)
+    #   puts queue.size #=> 3
+    #
+    # @rbs (untyped value) -> self
+    def push(value)
+      _push(value)
+    end
+    # Alias for {#push}.
+    #
+    # @rbs (untyped value) -> self
+    alias << push
+
+    # Dequeues the value at the head of the queue, or returns nil when
+    # the queue is empty.
+    #
+    # This operation is atomic and thread-safe. Multiple threads may
+    # pop concurrently without blocking one another.
+    #
+    # @return [untyped, nil] The dequeued value, or nil when the queue is empty
+    #
+    # @example
+    #   queue = AtomicQueue.new
+    #   queue.push(1)
+    #   queue.push(2)
+    #   puts queue.pop #=> 1
+    #   puts queue.pop #=> 2
+    #   puts queue.pop #=> nil
+    #
+    # @rbs () -> untyped
+    def pop
+      _pop
+    end
+
+    # Returns the number of values currently queued.
+    #
+    # This operation is atomic and thread-safe. The returned value
+    # reflects the state at the time of the call, but may change
+    # immediately after in concurrent environments.
+    #
+    # @return [Integer] The number of queued values
+    #
+    # @example
+    #   queue = AtomicQueue.new
+    #   queue.push(1)
+    #   queue.push(2)
+    #   puts queue.size #=> 2
+    #
+    # @rbs () -> Integer
+    def size
+      _size
+    end
+    # Alias for {#size}.
+    #
+    # @rbs () -> Integer
+    alias length size
+
+    # Returns true when the queue is empty.
+    #
+    # This operation is atomic and thread-safe. The returned value
+    # reflects the state at the time of the call, but may change
+    # immediately after in concurrent environments.
+    #
+    # @return [true, false] true when the queue has no values
+    #
+    # @example
+    #   queue = AtomicQueue.new
+    #   puts queue.empty? #=> true
+    #   queue.push(1)
+    #   puts queue.empty? #=> false
+    #
+    # @rbs () -> bool
+    def empty?
+      _empty_p
+    end
+  end
+end
+
+AtomicQueue = AtomicRuby::AtomicQueue

data/lib/atomic-ruby/atomic_thread_pool.rb

@@ -2,18 +2,17 @@
 # frozen_string_literal: true
 
 require_relative "atom"
+require_relative "atomic_boolean"
+require_relative "atomic_condition_variable"
+require_relative "atomic_queue"
 
 module AtomicRuby
   # Provides a fixed-size thread pool using atomic operations for work queuing.
   #
   # AtomicThreadPool maintains a fixed number of worker threads that process
-  # work items from an atomic queue. The pool uses compare-and-swap operations
-  # for thread-safe work enqueueing and state management.
-  #
-  # The queue is implemented as a two-stack structure (in/out) backed by
-  # immutable frozen linked-list nodes. Enqueueing prepends to the `in` stack
-  # in O(1); dequeueing pops from the `out` stack in O(1), reversing `in` into
-  # `out` only when `out` is exhausted (amortized O(1) per item).
+  # work items from an {AtomicQueue}. Both enqueueing and dequeueing are O(1)
+  # and lock-free, so concurrent producers and consumers never block one
+  # another.
   #
   # @example Basic usage
   #   pool = AtomicThreadPool.new(size: 4)
@@ -85,7 +84,9 @@ module AtomicRuby
       @name = name
       @on_error = on_error
 
-      @state = Atom.new(in: nil, out: nil, count: 0, shutdown: false)
+      @queue = AtomicQueue.new
+      @shutdown = AtomicBoolean.new(false)
+      @work_available = AtomicConditionVariable.new
       @started_thread_count = Atom.new(0)
       @active_thread_count = Atom.new(0)
       @threads = []
@@ -117,17 +118,10 @@ module AtomicRuby
     #
     # @rbs (Proc work) -> void
     def <<(work)
-      state = @state.swap do |current_state|
-        if current_state[:shutdown]
-          current_state
-        else
-          new_node = { value: work, next: current_state[:in] }.freeze
-          current_state.merge(in: new_node, count: current_state[:count] + 1)
-        end
-      end
-      raise EnqueuedWorkAfterShutdownError if state[:shutdown]
+      raise EnqueuedWorkAfterShutdownError if @shutdown.true?
 
-      @threads.each(&:wakeup)
+      @queue.push(work)
+      @work_available.signal
     end
 
     # Returns the number of currently alive worker threads.
@@ -168,7 +162,7 @@ module AtomicRuby
     #
     # @rbs () -> Integer
     def queue_length
-      @state.value[:count]
+      @queue.size
     end
     # Alias for {#queue_length}.
     #
@@ -225,17 +219,10 @@ module AtomicRuby
     #
     # @rbs () -> void
     def shutdown
-      already_shutdown = false
-      @state.swap do |current_state|
-        if current_state[:shutdown]
-          already_shutdown = true
-          current_state
-        else
-          current_state.merge(shutdown: true)
-        end
-      end
-      return if already_shutdown
+      return if @shutdown.true?
 
+      @shutdown.make_true
+      @work_available.broadcast
       @threads.each(&:join)
     end
 
@@ -263,40 +250,26 @@ module AtomicRuby
             work = nil
             should_shutdown = false
 
-            @state.swap do |current_state|
-              if current_state[:shutdown] && current_state[:in].nil? && current_state[:out].nil?
-                should_shutdown = true
-                current_state
-              elsif current_state[:out]
-                work = current_state[:out][:value]
-                current_state.merge(out: current_state[:out][:next], count: current_state[:count] - 1)
-              elsif current_state[:in]
-                new_out = reverse_list(current_state[:in])
-                work = new_out[:value]
-                current_state.merge(in: nil, out: new_out[:next], count: current_state[:count] - 1)
-              else
-                current_state
-              end
+            @work_available.wait do
+              work = @queue.pop
+              should_shutdown = @shutdown.true? && @queue.empty? unless work
+              work || should_shutdown
             end
 
-            if should_shutdown
-              break
-            elsif work
-              @active_thread_count.swap { |current_count| current_count + 1 }
-              begin
-                work.call
-              rescue => err
-                if @on_error
-                  @on_error.call(err)
-                else
-                  warn "#{thread_name} rescued:"
-                  warn err.full_message
-                end
-              ensure
-                @active_thread_count.swap { |current_count| current_count - 1 }
+            break if should_shutdown
+
+            @active_thread_count.swap { |current_count| current_count + 1 }
+            begin
+              work.call
+            rescue => err
+              if @on_error
+                @on_error.call(err)
+              else
+                warn "#{thread_name} rescued:"
+                warn err.full_message
               end
-            else
-              sleep 0.001
+            ensure
+              @active_thread_count.swap { |current_count| current_count - 1 }
             end
           end
         end
@@ -305,22 +278,6 @@ module AtomicRuby
 
       Thread.pass until @started_thread_count.value == @size
     end
-
-    # Reverses a linked-list of frozen nodes, returning a new reversed list.
-    # Each node in the returned list is a new frozen hash.
-    #
-    # @param node [Hash, nil] Head of the list to reverse
-    # @return [Hash, nil] Head of the reversed list
-    #
-    # @rbs (Hash? node) -> Hash?
-    def reverse_list(node)
-      reversed = nil
-      while node
-        reversed = { value: node[:value], next: reversed }.freeze
-        node = node[:next]
-      end
-      reversed
-    end
   end
 end
 

data/lib/atomic-ruby/version.rb

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

data/lib/atomic-ruby.rb

@@ -3,5 +3,7 @@
 require_relative "atomic-ruby/version"
 require_relative "atomic-ruby/atom"
 require_relative "atomic-ruby/atomic_boolean"
+require_relative "atomic-ruby/atomic_condition_variable"
+require_relative "atomic-ruby/atomic_queue"
 require_relative "atomic-ruby/atomic_thread_pool"
 require_relative "atomic-ruby/atomic_count_down_latch"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Joshua Young
@@ -27,7 +27,9 @@ files:
 - lib/atomic-ruby.rb
 - lib/atomic-ruby/atom.rb
 - lib/atomic-ruby/atomic_boolean.rb
+- lib/atomic-ruby/atomic_condition_variable.rb
 - lib/atomic-ruby/atomic_count_down_latch.rb
+- lib/atomic-ruby/atomic_queue.rb
 - lib/atomic-ruby/atomic_thread_pool.rb
 - lib/atomic-ruby/version.rb
 homepage: https://github.com/joshuay03/atomic-ruby
@@ -50,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Atomic primitives for Ruby
 test_files: []