Merge pull request #391 from ruby-concurrency/one-point-zero-pre-1

Initial preparation for 1.0.0.pre1

Author: jdantonio

CHANGELOG.md

@@ -1,3 +1,8 @@
+### Upcoming Release v1.0.0 (TBD)
+
+* Removed all deprecated code (classes, methods, constants, etc.)
+* Updated Agent, MutexAtomic, and BufferedChannel to inherit from Synchronization::Object.
+
 ## Current Release v0.9.1 (09 August 2015)
 
 * Fixed a Rubiniux bug in synchronization object

README.md

@@ -184,7 +184,7 @@ require 'concurrent/tvar'             # Concurrent::TVar
 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/channel'        # Concurrent::Channel and supporting code
 ```
 
 If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could help to reveal the problem.

lib/concurrent.rb

@@ -7,7 +7,6 @@
 require 'concurrent/atomics'
 require 'concurrent/errors'
 require 'concurrent/executors'
-require 'concurrent/utilities'
 
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/atom'

lib/concurrent/agent.rb

@@ -1,10 +1,9 @@
-require 'thread'
 require 'concurrent/collection/copy_on_write_observer_set'
 require 'concurrent/concern/dereferenceable'
 require 'concurrent/concern/observable'
 require 'concurrent/concern/logging'
 require 'concurrent/executor/executor'
-require 'concurrent/concern/deprecation'
+require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -81,11 +80,10 @@ module Concurrent
   #   @return [Fixnum] the maximum number of seconds before an update is cancelled
   #
   # @!macro edge_warning
-  class Agent
+  class Agent < Synchronization::Object
     include Concern::Dereferenceable
     include Concern::Observable
     include Concern::Logging
-    include Concern::Deprecation
 
     attr_reader :timeout, :io_executor, :fast_executor
 
@@ -95,15 +93,8 @@ class Agent
     #
     # @!macro executor_and_deref_options
     def initialize(initial, opts = {})
-      @value                = initial
-      @rescuers             = []
-      @validator            = Proc.new { |result| true }
-      self.observers        = Collection::CopyOnWriteObserverSet.new
-      @serialized_execution = SerializedExecution.new
-      @io_executor          = Executor.executor_from_options(opts) || Concurrent.global_io_executor
-      @fast_executor        = Executor.executor_from_options(opts) || Concurrent.global_fast_executor
-      init_mutex
-      set_deref_options(opts)
+      super()
+      synchronize { ns_initialize(initial, opts) }
     end
 
     # Specifies a block fast to be performed when an update fast raises
@@ -129,17 +120,15 @@ def initialize(initial, opts = {})
     #   #=> puts "Pow!"
     def rescue(clazz = StandardError, &block)
       unless block.nil?
-        mutex.synchronize do
-          @rescuers << Rescuer.new(clazz, block)
-        end
+        synchronize { @rescuers << Rescuer.new(clazz, block) }
       end
       self
     end
 
     alias_method :catch, :rescue
     alias_method :on_error, :rescue
 
-    # A block fast to be performed after every update to validate if the new
+    # A block task to be performed after every update to validate if the new
     # value is valid. If the new value is not valid then the current value is not
     # updated. If no validator is provided then all updates are considered valid.
     #
@@ -150,12 +139,7 @@ def rescue(clazz = StandardError, &block)
     def validate(&block)
 
       unless block.nil?
-        begin
-          mutex.lock
-          @validator = block
-        ensure
-          mutex.unlock
-        end
+        synchronize { @validator = block }
       end
       self
     end
@@ -179,30 +163,13 @@ def post(&block)
     # Update the current value with the result of the given block fast,
     # block can do blocking calls
     #
-    # @param [Fixnum, nil] timeout [DEPRECATED] maximum number of seconds before an update is cancelled
-    #
     # @yield the fast to be performed with the current value in order to calculate
     #   the new value
     # @yieldparam [Object] value the current value
     # @yieldreturn [Object] the new value
     # @return [true, nil] nil when no block is given
-    def post_off(timeout = nil, &block)
-      task = if timeout
-               deprecated 'post_off with option timeout options is deprecated and will be removed'
-               lambda do |value|
-                 future = Future.execute do
-                   block.call(value)
-                 end
-                 if future.wait(timeout)
-                   future.value!
-                 else
-                   raise Concurrent::TimeoutError
-                 end
-               end
-             else
-               block
-             end
-      post_on(@io_executor, &task)
+    def post_off(&block)
+      post_on(@io_executor, &block)
     end
 
     # Update the current value with the result of the given block fast,
@@ -227,6 +194,20 @@ def await(timeout = nil)
       done.wait timeout
     end
 
+    protected
+
+    def ns_initialize(initial, opts)
+      init_mutex(self)
+      @value                = initial
+      @rescuers             = []
+      @validator            = Proc.new { |result| true }
+      self.observers        = Collection::CopyOnWriteObserverSet.new
+      @serialized_execution = SerializedExecution.new
+      @io_executor          = Executor.executor_from_options(opts) || Concurrent.global_io_executor
+      @fast_executor        = Executor.executor_from_options(opts) || Concurrent.global_fast_executor
+      set_deref_options(opts)
+    end
+
     private
 
     def post_on(executor, &block)
@@ -240,7 +221,7 @@ def post_on(executor, &block)
 
     # @!visibility private
     def try_rescue(ex) # :nodoc:
-      rescuer = mutex.synchronize do
+      rescuer = synchronize do
         @rescuers.find { |r| ex.is_a?(r.clazz) }
       end
       rescuer.block.call(ex) if rescuer
@@ -251,7 +232,7 @@ def try_rescue(ex) # :nodoc:
 
     # @!visibility private
     def work(&handler) # :nodoc:
-      validator, value = mutex.synchronize { [@validator, @value] }
+      validator, value = synchronize { [@validator, @value] }
 
       begin
         result = handler.call(value)
@@ -260,14 +241,11 @@ def work(&handler) # :nodoc:
         exception = ex
       end
 
-      begin
-        mutex.lock
-        should_notify = if !exception && valid
-                          @value = result
-                          true
-                        end
-      ensure
-        mutex.unlock
+      should_notify = synchronize do
+        if !exception && valid
+          @value = result
+          true
+        end
       end
 
       if should_notify

lib/concurrent/async.rb

@@ -5,7 +5,6 @@
 require 'concurrent/ivar'
 require 'concurrent/executor/immediate_executor'
 require 'concurrent/executor/serialized_execution'
-require 'concurrent/concern/deprecation'
 
 module Concurrent
 
@@ -248,22 +247,6 @@ def executor=(executor)
         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.

lib/concurrent/atomic/atomic_reference.rb

@@ -40,10 +40,3 @@ class Concurrent::AtomicReference < Concurrent::CAtomicReference
   class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
   end
 end
-
-module Concurrent
-
-  # @see Concurrent::AtomicReference
-  # @deprecated Use Concurrent::AtomicReference instead.
-  Atomic = AtomicReference
-end

lib/concurrent/atomic/condition.rb

@@ -1,4 +1,4 @@
-require 'thread'
+require 'concurrent/synchronization'
 require 'concurrent/atomic_reference/direct_update'
 require 'concurrent/atomic_reference/numeric_cas_wrapper'
 
@@ -8,31 +8,31 @@ module Concurrent
   #
   # @!visibility private
   # @!macro internal_implementation_note
-  class MutexAtomicReference
+  class MutexAtomicReference < Synchronization::Object
     include Concurrent::AtomicDirectUpdate
     include Concurrent::AtomicNumericCompareAndSetWrapper
 
     # @!macro atomic_reference_method_initialize
     def initialize(value = nil)
-      @mutex = Mutex.new
-      @value = value
+      super()
+      synchronize { ns_initialize(value) }
     end
 
     # @!macro atomic_reference_method_get
     def get
-      @mutex.synchronize { @value }
+      synchronize { @value }
     end
     alias_method :value, :get
 
     # @!macro atomic_reference_method_set
     def set(new_value)
-      @mutex.synchronize { @value = new_value }
+      synchronize { @value = new_value }
     end
     alias_method :value=, :set
 
     # @!macro atomic_reference_method_get_and_set
     def get_and_set(new_value)
-      @mutex.synchronize do
+      synchronize do
         old_value = @value
         @value = new_value
         old_value
@@ -42,7 +42,7 @@ def get_and_set(new_value)
 
     # @!macro atomic_reference_method_compare_and_set
     def _compare_and_set(old_value, new_value)
-      @mutex.synchronize do
+      synchronize do
         if @value.equal? old_value
           @value = new_value
           true
@@ -51,5 +51,11 @@ def _compare_and_set(old_value, new_value)
         end
       end
     end
+
+    protected
+
+    def ns_initialize(value)
+      @value = value
+    end
   end
 end

lib/concurrent/atomic_reference/mutex_atomic.rb

@@ -73,7 +73,6 @@
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/atomic/atomic_boolean'
 require 'concurrent/atomic/atomic_fixnum'
-require 'concurrent/atomic/condition'
 require 'concurrent/atomic/cyclic_barrier'
 require 'concurrent/atomic/count_down_latch'
 require 'concurrent/atomic/event'