Do not depend on Synchronization::LockableObject for MutexAtomicBoolean and MutexAtomicFixnum

* Similar to MutexAtomicReference.
* Avoids allocating an extra ConditionVariable.
* Ensure the native extension version is used on CRuby in specs.

Author: eregon

lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb

@@ -1,5 +1,6 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
 require 'concurrent/atomic/mutex_atomic_boolean'
-require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -79,10 +80,10 @@ module Concurrent
   # @!visibility private
   # @!macro internal_implementation_note
   AtomicBooleanImplementation = case
-                                when defined?(JavaAtomicBoolean)
-                                  JavaAtomicBoolean
-                                when defined?(CAtomicBoolean)
+                                when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
                                   CAtomicBoolean
+                                when Concurrent.on_jruby?
+                                  JavaAtomicBoolean
                                 else
                                   MutexAtomicBoolean
                                 end

lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb

@@ -1,5 +1,6 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
 require 'concurrent/atomic/mutex_atomic_fixnum'
-require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -96,10 +97,10 @@ module Concurrent
   # @!visibility private
   # @!macro internal_implementation_note
   AtomicFixnumImplementation = case
-                               when defined?(JavaAtomicFixnum)
-                                 JavaAtomicFixnum
-                               when defined?(CAtomicFixnum)
+                               when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
                                  CAtomicFixnum
+                               when Concurrent.on_jruby?
+                                 JavaAtomicFixnum
                                else
                                  MutexAtomicFixnum
                                end

lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb

@@ -1,6 +1,5 @@
 require 'concurrent/utility/native_extension_loader' # load native parts first
 
-require 'concurrent/utility/engine'
 require 'concurrent/atomic_reference/numeric_cas_wrapper'
 
 # Shim for TruffleRuby::AtomicReference

lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb

@@ -1,15 +1,15 @@
-require 'concurrent/synchronization'
-
 module Concurrent
 
   # @!macro atomic_boolean
   # @!visibility private
   # @!macro internal_implementation_note
-  class MutexAtomicBoolean < Synchronization::LockableObject
+  class MutexAtomicBoolean
 
     # @!macro atomic_boolean_method_initialize
     def initialize(initial = false)
       super()
+      @__Lock__ = ::Mutex.new
+      # This synchronize should be good enough to ensure safe initialization
       synchronize { ns_initialize(initial) }
     end
 
@@ -45,6 +45,15 @@ def make_false
 
     protected
 
+    # @!visibility private
+    def synchronize
+      if @__Lock__.owned?
+        yield
+      else
+        @__Lock__.synchronize { yield }
+      end
+    end
+
     # @!visibility private
     def ns_initialize(initial)
       @value = !!initial

lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb

@@ -1,16 +1,17 @@
-require 'concurrent/synchronization'
 require 'concurrent/utility/native_integer'
 
 module Concurrent
 
   # @!macro atomic_fixnum
   # @!visibility private
   # @!macro internal_implementation_note
-  class MutexAtomicFixnum < Synchronization::LockableObject
+  class MutexAtomicFixnum
 
     # @!macro atomic_fixnum_method_initialize
     def initialize(initial = 0)
       super()
+      @__Lock__ = ::Mutex.new
+      # This synchronize should be good enough to ensure safe initialization
       synchronize { ns_initialize(initial) }
     end
 
@@ -59,6 +60,15 @@ def update
 
     protected
 
+    # @!visibility private
+    def synchronize
+      if @__Lock__.owned?
+        yield
+      else
+        @__Lock__.synchronize { yield }
+      end
+    end
+
     # @!visibility private
     def ns_initialize(initial)
       ns_set(initial)

lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb

@@ -51,6 +51,7 @@ def _compare_and_set(old_value, new_value)
 
     protected
 
+    # @!visibility private
     def synchronize
       if @__Lock__.owned?
         yield
@@ -59,6 +60,7 @@ def synchronize
       end
     end
 
+    # @!visibility private
     def ns_initialize(value)
       @value = value
     end

lib/concurrent-ruby/concurrent/utility/engine.rb

@@ -3,14 +3,14 @@ module Utility
 
     # @!visibility private
     module EngineDetector
-      def on_jruby?
-        RUBY_ENGINE == 'jruby'
-      end
-
       def on_cruby?
         RUBY_ENGINE == 'ruby'
       end
 
+      def on_jruby?
+        RUBY_ENGINE == 'jruby'
+      end
+
       def on_truffleruby?
         RUBY_ENGINE == 'truffleruby'
       end

spec/concurrent/atomic/atomic_boolean_spec.rb

@@ -140,15 +140,13 @@ module Concurrent
     end
   end
 
-  if defined? Concurrent::CAtomicBoolean
-
+  if Concurrent.allow_c_extensions?
     RSpec.describe CAtomicBoolean do
       it_should_behave_like :atomic_boolean
     end
   end
 
   if Concurrent.on_jruby?
-
     RSpec.describe JavaAtomicBoolean do
       it_should_behave_like :atomic_boolean
     end
@@ -165,7 +163,7 @@ module Concurrent
       it 'inherits from JavaAtomicBoolean' do
         expect(AtomicBoolean.ancestors).to include(JavaAtomicBoolean)
       end
-    elsif defined? Concurrent::CAtomicBoolean
+    elsif Concurrent.allow_c_extensions?
       it 'inherits from CAtomicBoolean' do
         expect(AtomicBoolean.ancestors).to include(CAtomicBoolean)
       end

spec/concurrent/atomic/atomic_fixnum_spec.rb

@@ -202,15 +202,13 @@ module Concurrent
     end
   end
 
-  if defined? Concurrent::CAtomicFixnum
-
+  if Concurrent.allow_c_extensions?
     RSpec.describe CAtomicFixnum do
       it_should_behave_like :atomic_fixnum
     end
   end
 
   if Concurrent.on_jruby?
-
     RSpec.describe JavaAtomicFixnum do
       it_should_behave_like :atomic_fixnum
     end
@@ -227,7 +225,7 @@ module Concurrent
       it 'inherits from JavaAtomicFixnum' do
         expect(AtomicFixnum.ancestors).to include(JavaAtomicFixnum)
       end
-    elsif defined? Concurrent::CAtomicFixnum
+    elsif Concurrent.allow_c_extensions?
       it 'inherits from CAtomicFixnum' do
         expect(AtomicFixnum.ancestors).to include(CAtomicFixnum)
       end

spec/concurrent/atomic/atomic_reference_spec.rb

@@ -161,17 +161,17 @@ module Concurrent
     it_should_behave_like :atomic_reference
   end
 
-  if defined? Concurrent::CAtomicReference
+  if Concurrent.allow_c_extensions?
     RSpec.describe CAtomicReference do
       it_should_behave_like :atomic_reference
     end
   end
-  if defined? Concurrent::JavaAtomicReference
+  if Concurrent.on_jruby?
     RSpec.describe JavaAtomicReference do
       it_should_behave_like :atomic_reference
     end
   end
-  if defined? Concurrent::TruffleRubyAtomicReference
+  if Concurrent.on_truffleruby?
     RSpec.describe TruffleRubyAtomicReference do
       it_should_behave_like :atomic_reference
     end