AtomicBoolean is now a Synchronization::Object.

Author: jdantonio

examples/benchmark_atomic_boolean.rb

@@ -6,6 +6,9 @@
 require 'benchmark'
 require 'rbconfig'
 
+THREADS = 1
+TESTS = 10_000_000
+
 def atomic_test(clazz, opts = {})
   threads = opts.fetch(:threads, 5)
   tests = opts.fetch(:tests, 100)
@@ -29,10 +32,10 @@ def atomic_test(clazz, opts = {})
 
 puts "Testing with #{RbConfig::CONFIG['ruby_install_name']} #{RUBY_VERSION}"
 
-atomic_test(Concurrent::MutexAtomicBoolean, threads: 10, tests: 1_000_000)
+atomic_test(Concurrent::MutexAtomicBoolean, threads: THREADS, tests: TESTS)
 
 if defined? Concurrent::CAtomicBoolean
-  atomic_test(Concurrent::CAtomicBoolean, threads: 10, tests: 1_000_000)
+  atomic_test(Concurrent::CAtomicBoolean, threads: THREADS, tests: TESTS)
 elsif RUBY_PLATFORM == 'java'
-  atomic_test(Concurrent::JavaAtomicBoolean, threads: 10, tests: 1_000_000)
+  atomic_test(Concurrent::JavaAtomicBoolean, threads: THREADS, tests: TESTS)
 end

lib/concurrent/atomic/atomic_boolean.rb

@@ -1,4 +1,5 @@
 require 'concurrent/native_extensions'
+require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -21,16 +22,15 @@ module Concurrent
   #         3.340000   0.010000   3.350000 (  0.855000)
   #
   #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
-  class MutexAtomicBoolean
+  class MutexAtomicBoolean < Synchronization::Object
 
     # @!macro [attach] atomic_boolean_method_initialize
     #
     #   Creates a new `AtomicBoolean` with the given initial value.
     #
     #   @param [Boolean] initial the initial value
     def initialize(initial = false)
-      @value = !!initial
-      @mutex = Mutex.new
+      super(initial)
     end
 
     # @!macro [attach] atomic_boolean_method_value_get
@@ -39,10 +39,7 @@ def initialize(initial = false)
     #
     #   @return [Boolean] the current value
     def value
-      @mutex.lock
-      @value
-    ensure
-      @mutex.unlock
+      synchronize { @value }
     end
 
     # @!macro [attach] atomic_boolean_method_value_set
@@ -53,11 +50,7 @@ def value
     #
     #   @return [Boolean] the current value
     def value=(value)
-      @mutex.lock
-      @value = !!value
-      @value
-    ensure
-      @mutex.unlock
+      synchronize { @value = !!value }
     end
 
     # @!macro [attach] atomic_boolean_method_true_question
@@ -66,10 +59,7 @@ def value=(value)
     #
     #   @return [Boolean] true if the current value is `true`, else false
     def true?
-      @mutex.lock
-      @value
-    ensure
-      @mutex.unlock
+      synchronize { @value }
     end
 
     # @!macro atomic_boolean_method_false_question
@@ -78,10 +68,7 @@ def true?
     #
     #   @return [Boolean] true if the current value is `false`, else false
     def false?
-      @mutex.lock
-      !@value
-    ensure
-      @mutex.unlock
+      synchronize { !@value }
     end
 
     # @!macro [attach] atomic_boolean_method_make_true
@@ -90,12 +77,7 @@ def false?
     #
     #   @return [Boolean] true is value has changed, otherwise false
     def make_true
-      @mutex.lock
-      old = @value
-      @value = true
-      !old
-    ensure
-      @mutex.unlock
+      synchronize { ns_make_value(true) }
     end
 
     # @!macro [attach] atomic_boolean_method_make_false
@@ -104,12 +86,19 @@ def make_true
     #
     #   @return [Boolean] true is value has changed, otherwise false
     def make_false
-      @mutex.lock
+      synchronize { ns_make_value(false) }
+    end
+
+    protected
+
+    def ns_initialize(initial)
+      @value = !!initial
+    end
+
+    def ns_make_value(value)
       old = @value
-      @value = false
-      old
-    ensure
-      @mutex.unlock
+      @value = value
+      old != @value
     end
   end
 

spec/concurrent/atomic/atomic_boolean_spec.rb

@@ -108,43 +108,34 @@ module Concurrent
 
     it_should_behave_like :atomic_boolean
 
-    specify 'construction is synchronized' do
-      mutex = double('mutex')
-      expect(Mutex).to receive(:new).once.with(no_args).and_return(mutex)
-      described_class.new
-    end
-
     context 'instance methods' do
 
       before(:each) do
-        mutex = double('mutex')
-        allow(Mutex).to receive(:new).with(no_args).and_return(mutex)
-        expect(mutex).to receive(:lock)
-        expect(mutex).to receive(:unlock)
+        expect(subject).to receive(:synchronize).with(no_args).and_return(true)
       end
 
       specify 'value is synchronized' do
-        described_class.new.value
+        subject.value
       end
 
       specify 'value= is synchronized' do
-        described_class.new.value = 10
+        subject.value = 10
       end
 
       specify 'true? is synchronized' do
-        described_class.new.true?
+        subject.true?
       end
 
       specify 'false? is synchronized' do
-        described_class.new.false?
+        subject.false?
       end
 
       specify 'make_true is synchronized' do
-        described_class.new.make_true
+        subject.make_true
       end
 
       specify 'make_false is synchronized' do
-        described_class.new.make_false
+        subject.make_false
       end
     end
   end