Add AtomicFixnum#update (similar to AtomicReference#update)

This will make the new read-write lock code which will be added soon more
concise. It will also be a useful addition to the AtomicFixnum API in its
own right.

Native C and Java implementations have been created for performance.

Author: alexdowad

ext/com/concurrent_ruby/ext/JavaAtomicFixnumLibrary.java

@@ -13,6 +13,7 @@
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.load.Library;
+import org.jruby.runtime.Block;
 
 public class JavaAtomicFixnumLibrary implements Library {
 
@@ -76,6 +77,18 @@ public IRubyObject compareAndSet(ThreadContext context, IRubyObject expect, IRub
             return getRuntime().newBoolean(atomicLong.compareAndSet(rubyFixnumToLong(expect), rubyFixnumToLong(update)));
         }
 
+        @JRubyMethod
+        public IRubyObject update(ThreadContext context, Block block) {
+            for (;;) {
+                long _oldValue       = atomicLong.get();
+                IRubyObject oldValue = getRuntime().newFixnum(_oldValue);
+                IRubyObject newValue = block.yield(context, oldValue);
+                if (atomicLong.compareAndSet(_oldValue, rubyFixnumToLong(newValue))) {
+                    return newValue;
+                }
+            }
+        }
+
         private long rubyFixnumToLong(IRubyObject value) {
             if (value instanceof RubyFixnum) {
                 RubyFixnum fixNum = (RubyFixnum) value;

ext/concurrent/atomic_fixnum.c

@@ -48,3 +48,14 @@ VALUE method_atomic_fixnum_compare_and_set(VALUE self, VALUE rb_expect, VALUE rb
   Check_Type(rb_update, T_FIXNUM);
   return ir_compare_and_set(self, rb_expect, rb_update);
 }
+
+VALUE method_atomic_fixnum_update(VALUE self) {
+  VALUE old_value, new_value;
+  for (;;) {
+    old_value = method_atomic_fixnum_value(self);
+    new_value = rb_yield(old_value);
+    if (ir_compare_and_set(self, old_value, new_value) == Qtrue) {
+      return new_value;
+    }
+  }
+}

ext/concurrent/atomic_fixnum.h

@@ -9,5 +9,6 @@ VALUE method_atomic_fixnum_value_set(VALUE, VALUE);
 VALUE method_atomic_fixnum_increment(VALUE);
 VALUE method_atomic_fixnum_decrement(VALUE);
 VALUE method_atomic_fixnum_compare_and_set(VALUE, VALUE, VALUE);
+VALUE method_atomic_fixnum_update(VALUE);
 
 #endif

ext/concurrent/rb_concurrent.c

@@ -52,6 +52,7 @@ void Init_extension() {
   rb_define_method(rb_cAtomicFixnum, "increment", method_atomic_fixnum_increment, 0);
   rb_define_method(rb_cAtomicFixnum, "decrement", method_atomic_fixnum_decrement, 0);
   rb_define_method(rb_cAtomicFixnum, "compare_and_set", method_atomic_fixnum_compare_and_set, 2);
+  rb_define_method(rb_cAtomicFixnum, "update", method_atomic_fixnum_update, 0);
   rb_define_alias(rb_cAtomicFixnum, "up", "increment");
   rb_define_alias(rb_cAtomicFixnum, "down", "decrement");
 }

lib/concurrent/atomic/atomic_fixnum.rb

@@ -106,6 +106,23 @@ def compare_and_set(expect, update)
       end
     end
 
+    # @!macro [attach] atomic_fixnum_method_update
+    #
+    # Pass the current value to the given block, replacing it
+    # with the block's result. May retry if the value changes
+    # during the block's execution.
+    #
+    # @yield [Object] Calculate a new value for the atomic reference using
+    #   given (old) value
+    # @yieldparam [Object] old_value the starting value of the atomic reference
+    #
+    # @return [Object] the new value
+    def update
+      synchronize do
+        @value = yield @value
+      end
+    end
+
     protected
 
     # @!visibility private

spec/concurrent/atomic/atomic_fixnum_spec.rb

@@ -108,6 +108,25 @@
       expect(f.value).to eq 14
     end
   end
+
+  context '#update' do
+
+    it 'passes the current value to the block' do
+      atomic = described_class.new(1000)
+      atomic.update { |v| (expect(v).to eq 1000); 1 }
+    end
+
+    it 'atomically sets the value to the return value from the block' do
+      atomic = described_class.new(1000)
+      atomic.update { |v| v + 1 }
+      expect(atomic.value).to eq 1001
+    end
+
+    it 'returns the new value' do
+      atomic = described_class.new(1000)
+      expect(atomic.update { |v| v + 1 }).to eq 1001
+    end
+  end
 end
 
 module Concurrent