Introduce AtomicMarkableReferenceState object

In order for the user to have a proper representation of the state of the
object at the time of the update, we must wrap the state of the object in a
new object.

Imagine the scenario if a user is simply given back the reference of the
actual AtomicMarkableReference object. The user cannot know what the values
were are the exact time of updating, because another thread could conceivably
alter that AtomicMarkableReference after the get returns.

Author: ianks

lib/concurrent/atomic_reference/mutex_markable_atomic.rb

@@ -7,6 +7,13 @@ module Concurrent
     class MutexAtomicMarkableReference
       include ::Concurrent::AtomicNumericCompareAndSetWrapper
 
+      # TODO: Temporary until ImmutableStruct is merged into master.
+      class AtomicMarkableReferenceState < Struct.new(:value, :marked)
+        def self.new(*args)
+          super(*args).freeze
+        end
+      end
+
       # @!macro [attach] atomic_markable_reference_method_initialize
       def initialize(value = nil, marked = false)
         @mutex = Mutex.new
@@ -19,7 +26,7 @@ def initialize(value = nil, marked = false)
       #
       #   @return [Array] the current reference and marked values
       def get
-        @mutex.synchronize { [@value, @marked] }
+        @mutex.synchronize { AtomicMarkableReferenceState.new @value, @marked }
       end
 
       # @!macro [attach] atomic_markable_reference_method_value
@@ -53,7 +60,7 @@ def set(new_val, new_mark)
         @mutex.synchronize do
           @value, @marked = new_val, new_mark
 
-          [@value, @marked]
+          AtomicMarkableReferenceState.new @value, @marked
         end
       end
 
@@ -75,7 +82,7 @@ def update
           new_val, new_mark = yield old_val, old_mark
 
           if compare_and_set old_val, new_val, old_mark, new_mark
-            return [new_val, new_mark]
+            return AtomicMarkableReferenceState.new new_val, new_mark
           end
         end
       end
@@ -105,7 +112,7 @@ def try_update
           fail(*err)
         end
 
-        [new_val, new_mark]
+        AtomicMarkableReferenceState.new new_val, new_mark
       end
 
       # @!macro [attach] atomic_markable_reference_method_compare_and_set

spec/concurrent/atomic/atomic_markable_reference_spec.rb

@@ -2,7 +2,7 @@
 shared_examples :atomic_markable_reference do
   # use a number outside JRuby's fixnum cache range, to ensure identity is
   # preserved
-  let(:atomic) { Edge::Concurrent::AtomicMarkableReference.new(1000, true) }
+  let(:atomic) { Edge::Concurrent::AtomicMarkableReference.new 1000, true }
 
   specify :test_construct do
     expect(atomic.value).to eq 1000
@@ -14,22 +14,28 @@
 
     expect(atomic.value).to eq 1001
     expect(atomic.marked?).to eq true
-    expect(res).to eq [1001, true]
+
+    expect(res.value).to eq 1001
+    expect(res.marked).to eq true
   end
 
   specify :test_update do
     res = atomic.update { |v, m| [v + 1, !m] }
 
     expect(atomic.marked?).to eq false
     expect(atomic.value).to eq 1001
-    expect(res).to eq [1001, false]
+
+    expect(res.value).to eq 1001
+    expect(res.marked).to eq false
   end
 
   specify :test_try_update do
     res = atomic.try_update { |v, m| [v + 1, !m] }
 
     expect(atomic.value).to eq 1001
-    expect(res).to eq [1001, false]
+
+    expect(res.value).to eq 1001
+    expect(res.marked).to eq false
   end
 
   specify :test_try_update_fails do