atomic-ruby 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 540189a4554f5e046af0b5305063a96be9fa58cfac1740e5e6076d6b1c48cd40
-  data.tar.gz: 528fa3c2e94c0d403ec8792076a773d3e7ce800852f1472dbde8e9ce7bbfb6f8
+  metadata.gz: 5a0461b3ac6fd6dbc7674cf028f8fb3727cad76da32ad2c6054a92a2818fe25f
+  data.tar.gz: 6f20eabbb25f29f6c43c166cbe240c1ddf2a6def437317c392a53fe86699a6b8
 SHA512:
-  metadata.gz: 8ad39592c8615f88aa0da987d1de06d87496c6c82481a9678c907937de65d308f4595e54008b0e357d99605fc660d8b35b986397ad0573e4b81dbf5de8926695
-  data.tar.gz: 46794d17727ab6b835210c7fc8e901d8c7daf37ff319c16b0efdb87cdc8bd9c95b6fb2dad171f96ca8d7b52b3fb8bd08cfde002f264cbe2155e6041310e74827
+  metadata.gz: 8e29e25f0790c2c3f3417efae11440a5f0500e0e943ce4c4a903f7fc4180342e832319cfe82712284449c876c70aa29ea22899480668bb1f35cc02c9369f8a6c
+  data.tar.gz: f26bc0f694a0e00cc84c9988761a1cf56c50c89d499bd70eb88b3fb896749ba36465d53d16e03d5ad636c8e8cd59b5b1f179bca827cd85c9a59397951bcd6013

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [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

data/README.md

@@ -65,11 +65,32 @@ Thread.pass until condvar.waiter_count == 1
 p condvar.waiter_count #=> 1
 
 ready.make_true
-p condvar.signal #=> 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
@@ -119,7 +140,9 @@ p latch.count #=> 0
 ```
 
 > [!NOTE]
-> `Atom`, `AtomicBoolean`, and `AtomicCountDownLatch` are Ractor-safe in Ruby 4.0+. `AtomicConditionVariable` is not, since it parks `Thread` references which cannot be shared across ractors.
+> `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
 
@@ -231,9 +254,9 @@ 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.5 (2026-05-20 revision 64336ffd0e) +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.13.0
+atomic-ruby version:     0.14.0
 
 Balances:
 Synchronized Bank Account Balance:           975
@@ -241,9 +264,9 @@ Concurrent Ruby Atomic Bank Account Balance: 975
 Atomic Ruby Atomic Bank Account Balance:     975
 
 Benchmark Results:
-Synchronized Bank Account:           5.109724 seconds
-Concurrent Ruby Atomic Bank Account: 5.137749 seconds
-Atomic Ruby Atomic Bank Account:     5.101637 seconds
+Synchronized Bank Account:           5.117072 seconds
+Concurrent Ruby Atomic Bank Account: 5.128366 seconds
+Atomic Ruby Atomic Bank Account:     5.110595 seconds
 ```
 
 </details>
@@ -322,23 +345,23 @@ end
 ```
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_boolean_benchmark.rb
 
-ruby version:            ruby 4.0.5 (2026-05-20 revision 64336ffd0e) +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.13.0
+atomic-ruby version:     0.14.0
 
 Warming up --------------------------------------
-          Synchronized Boolean Toggle   167.000 i/100ms
-Concurrent Ruby Atomic Boolean Toggle   132.000 i/100ms
-    Atomic Ruby Atomic Boolean Toggle   117.000 i/100ms
+          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.653k (± 2.0%) i/s  (605.04 μs/i) -      8.350k in   5.052096s
-Concurrent Ruby Atomic Boolean Toggle      1.313k (± 2.1%) i/s  (761.45 μs/i) -      6.600k in   5.025579s
-    Atomic Ruby Atomic Boolean Toggle      1.230k (± 4.8%) i/s  (812.86 μs/i) -      6.201k in   5.040557s
+          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:     1652.8 i/s
-Concurrent Ruby Atomic Boolean Toggle:     1313.3 i/s - 1.26x  slower
-    Atomic Ruby Atomic Boolean Toggle:     1230.2 i/s - 1.34x  slower
+          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>
@@ -406,19 +429,95 @@ end
 ```
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_condition_variable_benchmark.rb
 
-ruby version:        ruby 4.0.5 (2026-05-20 revision 64336ffd0e) +YJIT +PRISM [arm64-darwin23]
-atomic-ruby version: 0.13.0
+ruby version:        ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
+atomic-ruby version: 0.14.0
+
+Warming up --------------------------------------
+      Synchronized Condition Variable Wait/Signal     3.977k i/100ms
+Atomic Ruby Atomic Condition Variable Wait/Signal     3.885k 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
+
+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
+```
+
+</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 Condition Variable Wait/Signal     3.847k i/100ms
-Atomic Ruby Atomic Condition Variable Wait/Signal     3.704k i/100ms
+      Synchronized Queue Push/Pop   181.000 i/100ms
+Atomic Ruby Atomic Queue Push/Pop   132.000 i/100ms
 Calculating -------------------------------------
-      Synchronized Condition Variable Wait/Signal     38.661k (± 4.4%) i/s   (25.87 μs/i) -    196.197k in   5.074793s
-Atomic Ruby Atomic Condition Variable Wait/Signal     37.895k (± 4.7%) i/s   (26.39 μs/i) -    192.608k in   5.082648s
+      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 Condition Variable Wait/Signal:    38661.1 i/s
-Atomic Ruby Atomic Condition Variable Wait/Signal:    37895.2 i/s - same-ish: difference falls within error
+      Synchronized Queue Push/Pop:     1845.3 i/s
+Atomic Ruby Atomic Queue Push/Pop:     1431.3 i/s - 1.29x  slower
+
 ```
 
 </details>
@@ -474,13 +573,13 @@ puts "Atomic Ruby Atomic Thread Pool: #{results[1].real.round(6)} seconds"
 ```
 > bundle exec rake clobber && bundle exec rake compile && bundle exec ruby examples/atomic_thread_pool_benchmark.rb
 
-ruby version:            ruby 4.0.5 (2026-05-20 revision 64336ffd0e) +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.13.0
+atomic-ruby version:     0.14.0
 
 Benchmark Results:
-Concurrent Ruby Thread Pool:    5.792203 seconds
-Atomic Ruby Atomic Thread Pool: 5.504388 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

@@ -1,18 +1,19 @@
 # rbs_inline: enabled
 # frozen_string_literal: true
 
-require_relative "atom"
+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. Coordination is done by publishing the
-  # set of parked threads through an {Atom}, so all in-process
-  # synchronisation stays on the gem's CAS path. Parking still uses
-  # `Thread.stop` and `Thread#wakeup`, which are the standard kernel-level
-  # primitives Ruby exposes for sleeping a thread.
+  # `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
@@ -35,11 +36,8 @@ module AtomicRuby
   #
   # @example Worker loop draining an atomic queue
   #   condvar.wait do
-  #     work = nil
-  #     queue.swap do |q|
-  #       q.empty? ? q : (work = q.first; q.drop(1).freeze)
-  #     end
-  #     work
+  #     work = queue.pop
+  #     work || shutdown.true?
   #   end
   #
   # @note This class is NOT Ractor-safe as it parks `Thread` references,
@@ -52,7 +50,7 @@ module AtomicRuby
     #
     # @rbs () -> void
     def initialize
-      @waiters = Atom.new([].freeze)
+      _initialize
     end
 
     # Returns the number of currently parked waiters.
@@ -69,7 +67,7 @@ module AtomicRuby
     #
     # @rbs () -> Integer
     def waiter_count
-      @waiters.value.size
+      _waiter_count
     end
 
     # Wakes one parked waiter, or no-ops if none are parked.
@@ -86,18 +84,10 @@ module AtomicRuby
     #
     # @rbs () -> bool
     def signal
-      target = nil
-      @waiters.swap do |waiters|
-        if waiters.empty?
-          waiters
-        else
-          target = waiters.first
-          waiters.drop(1).freeze
-        end
-      end
-      return false unless target
+      thread = _shift_thread
+      return false unless thread
 
-      target.wakeup rescue nil
+      thread.wakeup rescue nil
       true
     end
 
@@ -113,13 +103,9 @@ module AtomicRuby
     #
     # @rbs () -> Integer
     def broadcast
-      targets = nil
-      @waiters.swap do |waiters|
-        targets = waiters
-        [].freeze
-      end
-      targets.each { |thread| thread.wakeup rescue nil }
-      targets.size
+      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
@@ -154,15 +140,15 @@ module AtomicRuby
 
       self_thread = Thread.current
       loop do
-        @waiters.swap { |waiters| (waiters + [self_thread]).freeze }
+        waiter = _add_waiter(self_thread)
         result = yield
         if result
-          @waiters.swap { |waiters| (waiters - [self_thread]).freeze }
+          _remove_waiter(waiter)
           return result
         end
 
         Thread.stop
-        @waiters.swap { |waiters| (waiters - [self_thread]).freeze }
+        _remove_waiter(waiter)
       end
     end
   end

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,19 +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)
@@ -86,7 +84,8 @@ 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)
@@ -119,16 +118,9 @@ 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?
 
+      @queue.push(work)
       @work_available.signal
     end
 
@@ -170,7 +162,7 @@ module AtomicRuby
     #
     # @rbs () -> Integer
     def queue_length
-      @state.value[:count]
+      @queue.size
     end
     # Alias for {#queue_length}.
     #
@@ -227,17 +219,9 @@ 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
@@ -267,21 +251,8 @@ module AtomicRuby
             should_shutdown = false
 
             @work_available.wait do
-              @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
-              end
+              work = @queue.pop
+              should_shutdown = @shutdown.true? && @queue.empty? unless work
               work || should_shutdown
             end
 
@@ -307,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.13.0"
+  VERSION = "0.14.0"
 end

data/lib/atomic-ruby.rb

@@ -4,5 +4,6 @@ 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.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Joshua Young
@@ -29,6 +29,7 @@ files:
 - 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
@@ -51,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: []