concurrent-ruby 0.9.2 → 1.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 470507742053628268cc6099862319dc532c8adf
-  data.tar.gz: 744b0057156c93efd399e7c85de3adfd20be090c
+  metadata.gz: 73752ee1b21c6a7bed99d034af965e1f7bc12af7
+  data.tar.gz: 1d1cfe49be663c6bef102761aae9dfa6e29e26e8
 SHA512:
-  metadata.gz: 86cb284c46ab9541832c4ba66dd57996750bb05af382a65a718569e46206204862d77c09c79ed9ba61823d0bc847af98c7766da81a4363034c84c0e4644e2712
-  data.tar.gz: eb9a12909e6726ba9ede889066b81fe6bbe2e787e8e12f124300d11b5343b577ddcb7469087fada3abb7c481ce71b63a6a6144355775ac2329c410dd49ceef00
+  metadata.gz: 0246cc3adb6b535e7d3149663e5ef771575b0c75d92509e8517853d13c1c06133b354573e5c900308bef5cab7f141dd06d0a89f79493841e6d1b19f6110088a3
+  data.tar.gz: b5e8453b5123206bdaed3cc8122eb65077638a33b977f2d103be998ae42180cfe5bc23fc8eb921a9aab17208f4a26b4826211dd7e76b6275ba82ea705a49aec9

data/CHANGELOG.md

@@ -1,4 +1,18 @@
-## Current Release v0.9.1 (09 August 2015)
+## Current Release v1.0.0.pre1 (19 Aug 2015)
+
+* Merged in the `thread_safe` gem
+  - `Concurrent::Array`
+  - `Concurrent::Hash`
+  - `Concurrent::Map` (formerly ThreadSafe::Cache)
+  - `Concurrent::Tuple`
+* Minor improvements to Concurrent::Map
+* Complete rewrite of `Exchanger`
+* Removed all deprecated code (classes, methods, constants, etc.)
+* Updated Agent, MutexAtomic, and BufferedChannel to inherit from Synchronization::Object.
+* Many improved tests
+* Some internal reorganization
+
+### Release v0.9.1 (09 August 2015)
 
 * Fixed a Rubiniux bug in synchronization object
 * Fixed all interpreter warnings (except circular references)

data/README.md

@@ -47,7 +47,7 @@
 
 MRI 1.9.3, 2.0, 2.1, 2.2, JRuby (1.9 mode), and Rubinius 2.x are supported.
 This gem should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.
-Java 8 is required for JRuby (Java 7 support is deprecated in version 0.9 and will be removed in 1.0).
+Java 8 is preferred for JRuby but every Java version on which JRuby 9000 runs will be supported.
 
 ## Features & Documentation
 
@@ -62,54 +62,62 @@ This library contains a variety of concurrency abstractions at high and low leve
 #### General-purpose Concurrency Abstractions
 
 * [Async](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Async.html): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
-* [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, synchronous, independent state.
 * [Future](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Future.html): An asynchronous operation that produces a value.
   * [Dataflow](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#dataflow-class_method): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
 * [Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html): Similar to Futures, with more features.
 * [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ScheduledTask.html): Like a Future scheduled for a specific future time.
 * [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html): A Thread that periodically wakes up to perform work at regular intervals.
 
-#### Thread-safe Value Objects
+#### Thread-safe Value Objects, Structures, and Collections
+
+Collection classes that were originally part of the (deprecated) `thread_safe` gem:
+
+* [Array](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Array.html) A thread-safe subclass of Ruby's standard [Array](http://ruby-doc.org/core-2.2.0/Array.html).
+* [Hash](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Hash.html) A thread-safe subclass of Ruby's standard [Hash](http://ruby-doc.org/core-2.2.0/Hash.html).
+* [Map](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Map.html) A hash-like object that should have much better performance characteristics, especially under high concurrency, than `Concurrent::Hash`.
+* [Tuple](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Tuple.html) A fixed size array with volatile (synchronized, thread safe) getters/setters.
+
+Value objects inspired by other languages:
 
-* `Maybe` A thread-safe, immutable object representing an optional value, based on
+* [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, synchronous, independent state.
+* [Maybe](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Maybe.html) A thread-safe, immutable object representing an optional value, based on
   [Haskell Data.Maybe](https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html).
-* `Delay` Lazy evaluation of a block yielding an immutable result. Based on Clojure's
+* [Delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html) Lazy evaluation of a block yielding an immutable result. Based on Clojure's
    [delay](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Delay.html).
 
-#### Thread-safe Structures
+Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
+
+* [ImmutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ImmutableStruct.html) Immutable struct where values are set at construction and cannot be changed later.
+* [MutableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutableStruct.html) Synchronized, mutable struct where values can be safely changed at any time.
+* [SettableStruct](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/SettableStruct.html) Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
 
-Derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/Struct.html):
+Thread-safe variables:
 
-* `ImmutableStruct` Immutable struct where values are set at construction and cannot be changed later.
-* `MutableStruct` Synchronized, mutable struct where values can be safely changed at any time.
-* `SettableStruct` Synchronized, write-once struct where values can be set at most once, either at construction or any time thereafter.
+* [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html) A boolean value that can be updated atomically.
+* [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html) A numeric value that can be updated atomically.
+* [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html) An object reference that may be updated atomically.
+* [ThreadLocalVar](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html) A variable where the value is different for each thread.
 
 #### Java-inspired ThreadPools and Other Executors
 
-* See [ThreadPool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
+* See the [thread pool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
 
 #### Thread Synchronization Classes and Algorithms
 
-* [CountdownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html)
-* [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html)
-* [Event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html)
-* [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html)
-
-#### Thread-safe Variables
-
-* [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html)
-* [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html)
-* [AtomicReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MutexAtomic.html)
-* [I-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar)
-* [M-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar)
-* [Thread-local variables](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html)
-* [Software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar)
-* [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html)
-* [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReentrantReadWriteLock.html)
+* [CountdownLatch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html) A synchronization object that allows one thread to wait on multiple other threads.
+* [CyclicBarrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html) A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.
+* [Event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html) Old school kernel-style event.
+* [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
+* [I-Structure](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar) Similar to a "future" but can be manually assigned once, after which it becomes immutable.
+* [M-Structure](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar) A synchronized single element container.
+* [ReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReadWriteLock.html) A lock that supports multiple readers but only one writer.
+* [ReentrantReadWriteLock](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ReentrantReadWriteLock.html) A read/write lock with reentrant and upgrade features.
+* [Semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html) A counting-based locking mechanism that uses permits.
+* [Software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar) A transactional variable - a single-element container that is used as part of a transaction.
 
 ### Edge Features
 
-These are available in the `concurrent-ruby-edge` companion gem, installed with `gem install concurrent-ruby-edge`.
+These are available in the `concurrent-ruby-edge` companion gem.
 
 These features are under active development and may change frequently. They are expected not to
 keep backward compatibility (there may also lack tests and documentation). Semantic versions will
@@ -125,10 +133,9 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 * [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A single atomic value that represents an identity.
 * [Channel](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Channel.html):
   Communicating Sequential Processes (CSP).
-* [Exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
 * [LazyRegister](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/LazyRegister.html)
-* [Atomic Markable Reference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
-* [LockFreeLinked Set](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
+* [AtomicMarkableReference](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/AtomicMarkableReference.html)
+* [LockFreeLinkedSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeLinkedSet.html)
 * [LockFreeStack](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Edge/LockFreeStack.html)
 
 #### Statuses:
@@ -139,52 +146,21 @@ be obeyed though. Features developed in `concurrent-ruby-edge` are expected to m
 - **Future/Promise Framework** - API changes; partial documentation and tests; stability good.
 - **Agent** - Incomplete behaviour compared to Clojure's models; stability good.
 - **Channel** - Missing documentation; limted features; stability good.
-- **Exchanger** - Known race condition requiring a new implementation.
 - **LazyRegister** - Missing documentation and tests.
 - **AtomicMarkableReference, LockFreeLinkedSet, LockFreeStack** - Needs real world battle testing
 
 ## Usage
 
-All abstractions within this gem can be loaded simply by requiring it:
+Everything within this gem can be loaded simply by requiring it:
 
 ```ruby
 require 'concurrent'
 ```
 
-To reduce the amount of code loaded at runtime, subsets of this gem can be required:
+To use the tools in the Edge gem it must be required separately:
 
 ```ruby
-require 'concurrent'                # everything
-
-# groups
-
-require 'concurrent/atomics'        # atomic and thread synchronization classes
-require 'concurrent/executors'      # Thread pools and other executors
-
-# individual abstractions
-
-require 'concurrent/async'            # Concurrent::Async
-require 'concurrent/atom'             # Concurrent::Atom
-require 'concurrent/dataflow'         # Concurrent::dataflow
-require 'concurrent/delay'            # Concurrent::Delay
-require 'concurrent/future'           # Concurrent::Future
-require 'concurrent/immutable_struct' # Concurrent::ImmutableStruct
-require 'concurrent/ivar'             # Concurrent::IVar
-require 'concurrent/maybe'            # Concurrent::Maybe
-require 'concurrent/mutable_struct'   # Concurrent::MutableStruct
-require 'concurrent/mvar'             # Concurrent::MVar
-require 'concurrent/promise'          # Concurrent::Promise
-require 'concurrent/scheduled_task'   # Concurrent::ScheduledTask
-require 'concurrent/settable_struct'  # Concurrent::SettableStruct
-require 'concurrent/timer_task'       # Concurrent::TimerTask
-require 'concurrent/tvar'             # Concurrent::TVar
-
-# experimental - available in `concurrent-ruby-edge` companion gem
-
-require 'concurrent/actor'          # Concurrent::Actor and supporting code
-require 'concurrent/edge/future'    # new Future Framework
-require 'concurrent/agent'          # Concurrent::Agent
-require 'concurrent/channel '       # Concurrent::Channel and supporting code
+require 'concurrent-edge'
 ```
 
 If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could help to reveal the problem.
@@ -203,6 +179,23 @@ gem 'concurrent-ruby'
 
 and run `bundle install` from your shell.
 
+### Edge Gem Installation
+
+The Edge gem must be installed separately from the core gem:
+
+```shell
+gem install concurrent-ruby-edge
+```
+
+or add the following line to Gemfile:
+
+```ruby
+gem 'concurrent-ruby-edge'
+```
+
+and run `bundle install` from your shell.
+
+
 ### C Extensions for MRI
 
 Potential performance improvements may be achieved under MRI by installing optional C extensions.
@@ -240,7 +233,7 @@ The best practice is to depend on `concurrent-ruby` and let users to decide if t
 
 All published versions of this gem (core, extension, and several platform-specific packages) are compiled,
 packaged, tested, and published using an open, [automated process](https://github.com/ruby-concurrency/rake-compiler-dev-box).
-This process can also be used to create pre-compiled binaries of the extension gem for virtally
+This process can also be used to create pre-compiled binaries of the extension gem for virtually
 any platform. *Documentation is forthcoming...*
 
 ```
@@ -272,11 +265,17 @@ bundle exec rake compile            # Compile all the extensions
 ## Maintainers
 
 * [Jerry D'Antonio](https://github.com/jdantonio) (creator)
+* [Petr Chalupa](https://github.com/pitr-ch)
 * [Michele Della Torre](https://github.com/mighe)
 * [Chris Seaton](https://github.com/chrisseaton)
-* [Lucas Allan](https://github.com/lucasallan)
-* [Petr Chalupa](https://github.com/pitr-ch)
 * [Paweł Obrok](https://github.com/obrok)
+* [Lucas Allan](https://github.com/lucasallan)
+
+### Special Thanks
+
+* [Brian Durand](https://github.com/bdurand) for the `ref` gem
+* [Charles Oliver Nutter](https://github.com/headius) for the `atomic` and `thread_safe` gems
+* [thedarkone](https://github.com/thedarkone) for the `thread_safe` gem
 
 ## Contributing
 

data/lib/concurrent.rb

@@ -7,13 +7,17 @@ require 'concurrent/configuration'
 require 'concurrent/atomics'
 require 'concurrent/errors'
 require 'concurrent/executors'
-require 'concurrent/utilities'
 
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/atom'
+require 'concurrent/array'
+require 'concurrent/hash'
+require 'concurrent/map'
+require 'concurrent/tuple'
 require 'concurrent/async'
 require 'concurrent/dataflow'
 require 'concurrent/delay'
+require 'concurrent/exchanger'
 require 'concurrent/future'
 require 'concurrent/immutable_struct'
 require 'concurrent/ivar'
@@ -26,6 +30,10 @@ require 'concurrent/settable_struct'
 require 'concurrent/timer_task'
 require 'concurrent/tvar'
 
+require 'concurrent/thread_safe/synchronized_delegator'
+require 'concurrent/thread_safe/util'
+
+
 # @!macro [new] internal_implementation_note
 #
 #   @note **Private Implementation:** This abstraction is a private, internal
@@ -118,4 +126,9 @@ require 'concurrent/tvar'
 # * Be small, lean, and loosely coupled
 module Concurrent
 
+  # Various classes within allows for +nil+ values to be stored,
+  # so a special +NULL+ token is required to indicate the "nil-ness".
+  # @!visibility private
+  NULL = Object.new
+
 end

data/lib/concurrent/array.rb

@@ -0,0 +1,38 @@
+require 'concurrent/utility/engine'
+require 'concurrent/thread_safe/util'
+
+module Concurrent
+  if Concurrent.on_cruby?
+
+    # Because MRI never runs code in parallel, the existing
+    # non-thread-safe structures should usually work fine.
+
+    # @!macro [attach] concurrent_array
+    #
+    #   A thread-safe subclass of Array. This version locks against the object
+    #   itself for every method call, ensuring only one thread can be reading
+    #   or writing at a time. This includes iteration methods like `#each`.
+    #
+    #   @see http://ruby-doc.org/core-2.2.0/Array.html Ruby standard library `Array`
+    class Array < ::Array;
+    end
+
+  elsif Concurrent.on_jruby?
+    require 'jruby/synchronized'
+
+    # @!macro concurrent_array
+    class Array < ::Array
+      include JRuby::Synchronized
+    end
+
+  elsif Concurrent.on_rbx?
+    require 'monitor'
+
+    # @!macro concurrent_array
+    class Array < ::Array
+    end
+
+    ThreadSafe::Util.make_synchronized_on_rbx Array
+  end
+end
+

data/lib/concurrent/async.rb

@@ -5,7 +5,6 @@ require 'concurrent/errors'
 require 'concurrent/ivar'
 require 'concurrent/executor/immediate_executor'
 require 'concurrent/executor/serialized_execution'
-require 'concurrent/concern/deprecation'
 
 module Concurrent
 
@@ -248,22 +247,6 @@ module Concurrent
         raise ArgumentError.new('executor has already been set')
     end
 
-    # Initialize the internal serializer and other stnchronization mechanisms.
-    #
-    # @note This method *must* be called immediately upon object construction.
-    #   This is the only way thread-safe initialization can be guaranteed.
-    #
-    # @raise [Concurrent::InitializationError] when called more than once
-    #
-    # @!visibility private
-    # @deprecated
-    def init_mutex
-      deprecated 'mutex synchronization now happens automatically'
-      init_synchronization
-    rescue InitializationError
-      # suppress
-    end
-
     private
 
     # Initialize the internal serializer and other stnchronization mechanisms.

data/lib/concurrent/atomic/abstract_thread_local_var.rb

@@ -0,0 +1,40 @@
+module Concurrent
+
+  # @!macro thread_local_var
+  # @!macro internal_implementation_note
+  # @!visibility private
+  class AbstractThreadLocalVar
+
+    # @!visibility private
+    NIL_SENTINEL = Object.new
+    private_constant :NIL_SENTINEL
+
+    # @!macro thread_local_var_method_initialize
+    def initialize(default = nil)
+      @default = default
+      allocate_storage
+    end
+
+    # @!macro thread_local_var_method_get
+    def value
+      raise NotImplementedError
+    end
+
+    # @!macro thread_local_var_method_set
+    def value=(value)
+      raise NotImplementedError
+    end
+
+    # @!macro thread_local_var_method_bind
+    def bind(value, &block)
+      raise NotImplementedError
+    end
+
+    protected
+
+    # @!visibility private
+    def allocate_storage
+      raise NotImplementedError
+    end
+  end
+end

data/lib/concurrent/atomic/atomic_boolean.rb

@@ -1,113 +1,80 @@
+require 'concurrent/atomic/mutex_atomic_boolean'
 require 'concurrent/utility/native_extension_loader'
-require 'concurrent/synchronization'
 
 module Concurrent
 
-  # @!macro [attach] atomic_boolean
+  ###################################################################
+
+  # @!macro [new] atomic_boolean_method_initialize
   #
-  #   A boolean value that can be updated atomically. Reads and writes to an atomic
-  #   boolean and thread-safe and guaranteed to succeed. Reads and writes may block
-  #   briefly but no explicit locking is required.
+  #   Creates a new `AtomicBoolean` with the given initial value.
   #
-  #       Testing with ruby 2.1.2
-  #       Testing with Concurrent::MutexAtomicBoolean...
-  #         2.790000   0.000000   2.790000 (  2.791454)
-  #       Testing with Concurrent::CAtomicBoolean...
-  #         0.740000   0.000000   0.740000 (  0.740206)
+  #   @param [Boolean] initial the initial value
+
+  # @!macro [new] atomic_boolean_method_value_get
   #
-  #       Testing with jruby 1.9.3
-  #       Testing with Concurrent::MutexAtomicBoolean...
-  #         5.240000   2.520000   7.760000 (  3.683000)
-  #       Testing with Concurrent::JavaAtomicBoolean...
-  #         3.340000   0.010000   3.350000 (  0.855000)
+  #   Retrieves the current `Boolean` value.
   #
-  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
+  #   @return [Boolean] the current value
+
+  # @!macro [new] atomic_boolean_method_value_set
   #
-  # @!visibility private
+  #   Explicitly sets the value.
   #
-  # @!macro internal_implementation_note
-  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)
-      super()
-      synchronize { ns_initialize(initial) }
-    end
-
-    # @!macro [attach] atomic_boolean_method_value_get
-    #
-    #   Retrieves the current `Boolean` value.
-    #
-    #   @return [Boolean] the current value
-    def value
-      synchronize { @value }
-    end
-
-    # @!macro [attach] atomic_boolean_method_value_set
-    #
-    #   Explicitly sets the value.
-    #
-    #   @param [Boolean] value the new value to be set
-    #
-    #   @return [Boolean] the current value
-    def value=(value)
-      synchronize { @value = !!value }
-    end
-
-    # @!macro [attach] atomic_boolean_method_true_question
-    #
-    #   Is the current value `true`
-    #
-    #   @return [Boolean] true if the current value is `true`, else false
-    def true?
-      synchronize { @value }
-    end
+  #   @param [Boolean] value the new value to be set
+  #
+  #   @return [Boolean] the current value
 
-    # @!macro [attach] atomic_boolean_method_false_question
-    #
-    #   Is the current value `false`
-    #
-    #   @return [Boolean] true if the current value is `false`, else false
-    def false?
-      synchronize { !@value }
-    end
+  # @!macro [new] atomic_boolean_method_true_question
+  #
+  #   Is the current value `true`
+  #
+  #   @return [Boolean] true if the current value is `true`, else false
 
-    # @!macro [attach] atomic_boolean_method_make_true
-    #
-    #   Explicitly sets the value to true.
-    #
-    #   @return [Boolean] true is value has changed, otherwise false
-    def make_true
-      synchronize { ns_make_value(true) }
-    end
+  # @!macro [new] atomic_boolean_method_false_question
+  #
+  #   Is the current value `false`
+  #
+  #   @return [Boolean] true if the current value is `false`, else false
 
-    # @!macro [attach] atomic_boolean_method_make_false
-    #
-    #   Explicitly sets the value to false.
-    #
-    #   @return [Boolean] true is value has changed, otherwise false
-    def make_false
-      synchronize { ns_make_value(false) }
-    end
+  # @!macro [new] atomic_boolean_method_make_true
+  #
+  #   Explicitly sets the value to true.
+  #
+  #   @return [Boolean] true is value has changed, otherwise false
 
-    protected
+  # @!macro [new] atomic_boolean_method_make_false
+  #
+  #   Explicitly sets the value to false.
+  #
+  #   @return [Boolean] true is value has changed, otherwise false
+  
+  ###################################################################
 
-    # @!visibility private
-    def ns_initialize(initial)
-      @value = !!initial
-    end
+  # @!macro [new] atomic_boolean_public_api
+  #
+  #   @!method initialize(initial = false)
+  #     @!macro  atomic_boolean_method_initialize
+  #
+  #   @!method value
+  #     @!macro  atomic_boolean_method_value_get
+  #
+  #   @!method value=(value)
+  #     @!macro  atomic_boolean_method_value_set
+  #
+  #   @!method true?
+  #     @!macro  atomic_boolean_method_true_question
+  #
+  #   @!method false?
+  #     @!macro  atomic_boolean_method_false_question
+  #
+  #   @!method make_true
+  #     @!macro  atomic_boolean_method_make_true
+  #
+  #   @!method make_false
+  #     @!macro  atomic_boolean_method_make_false
 
-    # @!visibility private
-    def ns_make_value(value)
-      old = @value
-      @value = value
-      old != @value
-    end
-  end
+  ###################################################################
 
   # @!visibility private
   # @!macro internal_implementation_note
@@ -121,31 +88,27 @@ module Concurrent
                                 end
   private_constant :AtomicBooleanImplementation
 
-  # @!macro atomic_boolean
+  # @!macro [attach] atomic_boolean
+  #
+  #   A boolean value that can be updated atomically. Reads and writes to an atomic
+  #   boolean and thread-safe and guaranteed to succeed. Reads and writes may block
+  #   briefly but no explicit locking is required.
+  #
+  #       Testing with ruby 2.1.2
+  #       Testing with Concurrent::MutexAtomicBoolean...
+  #         2.790000   0.000000   2.790000 (  2.791454)
+  #       Testing with Concurrent::CAtomicBoolean...
+  #         0.740000   0.000000   0.740000 (  0.740206)
+  #
+  #       Testing with jruby 1.9.3
+  #       Testing with Concurrent::MutexAtomicBoolean...
+  #         5.240000   2.520000   7.760000 (  3.683000)
+  #       Testing with Concurrent::JavaAtomicBoolean...
+  #         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
   #
-  # @see Concurrent::MutexAtomicBoolean
+  # @!macro atomic_boolean_public_api
   class AtomicBoolean < AtomicBooleanImplementation
-
-    # @!method initialize(initial = false)
-    #   @!macro atomic_boolean_method_initialize
-
-    # @!method value
-    #   @!macro atomic_boolean_method_value_get
-
-    # @!method value=(value)
-    #   @!macro atomic_boolean_method_value_set
-
-    # @!method true?
-    #   @!macro atomic_boolean_method_true_question
-
-    # @!method false?
-    #   @!macro atomic_boolean_method_false_question
-
-    # @!method make_true
-    #   @!macro atomic_boolean_method_make_true
-
-    # @!method make_false
-    #   @!macro atomic_boolean_method_make_false
-
   end
 end