concurrent-ruby 0.9.2-java → 1.0.0-java

data/lib/concurrent/concern/dereferenceable.rb

@@ -9,13 +9,17 @@ module Concurrent
     #
     # @!macro copy_options
     module Dereferenceable
+      # NOTE: This module is going away in 2.0. In the mean time we need it to
+      # play nicely with the synchronization layer. This means that the
+      # including class SHOULD be synchronized and it MUST implement a
+      # `#synchronize` method. Not doing so will lead to runtime errors.
 
       # Return the value this object represents after applying the options specified
       # by the `#set_deref_options` method.
       #
       # @return [Object] the current value of the object
       def value
-        mutex.synchronize { apply_deref_options(@value) }
+        synchronize { apply_deref_options(@value) }
       end
       alias_method :deref, :value
 
@@ -25,43 +29,24 @@ module Concurrent
       #
       # @param [Object] value the new value
       def value=(value)
-        mutex.synchronize{ @value = value }
-      end
-
-      # A mutex lock used for synchronizing thread-safe operations. Methods defined
-      # by `Dereferenceable` are synchronized using the `Mutex` returned from this
-      # method. Operations performed by the including class that operate on the
-      # `@value` instance variable should be locked with this `Mutex`.
-      #
-      # @return [Mutex] the synchronization object
-      def mutex
-        @mutex
-      end
-
-      # Initializes the internal `Mutex`.
-      #
-      # @note This method *must* be called from within the constructor of the including class.
-      #
-      # @see #mutex
-      def init_mutex(mutex = Mutex.new)
-        @mutex = mutex
+        synchronize{ @value = value }
       end
 
       # @!macro [attach] dereferenceable_set_deref_options
       #   Set the options which define the operations #value performs before
       #   returning data to the caller (dereferencing).
-      #  
+      #
       #   @note Most classes that include this module will call `#set_deref_options`
       #   from within the constructor, thus allowing these options to be set at
       #   object creation.
-      #  
+      #
       #   @param [Hash] opts the options defining dereference behavior.
       #   @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
       #   @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
       #   @option opts [String] :copy_on_deref (nil) call the given `Proc` passing
       #     the internal value and returning the value returned from the proc
       def set_deref_options(opts = {})
-        mutex.synchronize{ ns_set_deref_options(opts) }
+        synchronize{ ns_set_deref_options(opts) }
       end
 
       # @!macro dereferenceable_set_deref_options

data/lib/concurrent/concern/logging.rb

@@ -9,7 +9,7 @@ module Concurrent
     module Logging
       include Logger::Severity
 
-      # Logs through {Configuration#logger}, it can be overridden by setting @logger
+      # Logs through {Concurrent.global_logger}, it can be overridden by setting @logger
       # @param [Integer] level one of Logger::Severity constants
       # @param [String] progname e.g. a path of an Actor
       # @param [String, nil] message when nil block is used to generate the message

data/lib/concurrent/concern/obligation.rb

@@ -3,14 +3,16 @@ require 'timeout'
 
 require 'concurrent/atomic/event'
 require 'concurrent/concern/dereferenceable'
-require 'concurrent/concern/deprecation'
 
 module Concurrent
   module Concern
 
     module Obligation
       include Concern::Dereferenceable
-      include Concern::Deprecation
+      # NOTE: The Dereferenceable module is going away in 2.0. In the mean time
+      # we need it to place nicely with the synchronization layer. This means
+      # that the including class SHOULD be synchronized and it MUST implement a
+      # `#synchronize` method. Not doing so will lead to runtime errors.
 
       # Has the obligation been fulfilled?
       #
@@ -48,16 +50,6 @@ module Concurrent
         [:fulfilled, :rejected].include? state
       end
 
-      # Has the obligation completed processing?
-      #
-      # @return [Boolean]
-      #
-      # @deprecated
-      def completed?
-        deprecated_method 'completed?', 'complete?'
-        complete?
-      end
-
       # Is the obligation still awaiting completion of processing?
       #
       # @return [Boolean]
@@ -116,7 +108,7 @@ module Concurrent
       #
       # @return [Symbol] the current state
       def state
-        mutex.synchronize { @state }
+        synchronize { @state }
       end
 
       # If an exception was raised during processing this will return the
@@ -125,7 +117,7 @@ module Concurrent
       #
       # @return [Exception] the exception raised during processing or `nil`
       def reason
-        mutex.synchronize { @reason }
+        synchronize { @reason }
       end
 
       # @example allows Obligation to be risen
@@ -144,8 +136,7 @@ module Concurrent
       end
 
       # @!visibility private
-      def init_obligation(*args)
-        init_mutex(*args)
+      def init_obligation
         @event = Event.new
       end
 
@@ -167,7 +158,7 @@ module Concurrent
 
       # @!visibility private
       def state=(value)
-        mutex.synchronize { ns_set_state(value) }
+        synchronize { ns_set_state(value) }
       end
 
       # Atomic compare and set operation
@@ -175,12 +166,12 @@ module Concurrent
       #
       # @param [Symbol] next_state
       # @param [Symbol] expected_current
-      # 
+      #
       # @return [Boolean] true is state is changed, false otherwise
       #
       # @!visibility private
       def compare_and_set_state(next_state, *expected_current)
-        mutex.synchronize do
+        synchronize do
           if expected_current.include? @state
             @state = next_state
             true
@@ -196,7 +187,7 @@ module Concurrent
       #
       # @!visibility private
       def if_state(*expected_states)
-        mutex.synchronize do
+        synchronize do
           raise ArgumentError.new('no block given') unless block_given?
 
           if expected_states.include? @state

data/lib/concurrent/concern/observable.rb

@@ -21,8 +21,8 @@ module Concurrent
     #
     # In a multi threaded environment things are more complex. The `subject` must
     # synchronize the access to its data structure and to do so currently we're
-    # using two specialized ObserverSet: CopyOnWriteObserverSet and
-    # CopyOnNotifyObserverSet.
+    # using two specialized ObserverSet: {Concurrent::Concern::CopyOnWriteObserverSet}
+    # and {Concurrent::Concern::CopyOnNotifyObserverSet}.
     #
     # When implementing and `observer` there's a very important rule to remember:
     # **there are no guarantees about the thread that will execute the callback**
@@ -49,30 +49,55 @@ module Concurrent
     # or an AtomicFixum)
     module Observable
 
-      # @return [Object] the added observer
-      def add_observer(*args, &block)
-        observers.add_observer(*args, &block)
+      # @!macro [attach] observable_add_observer
+      #
+      #   Adds an observer to this set. If a block is passed, the observer will be
+      #   created by this method and no other params should be passed.
+      #
+      #   @param [Object] observer the observer to add
+      #   @param [Symbol] func the function to call on the observer during notification.
+      #     Default is :update
+      #   @return [Object] the added observer
+      def add_observer(observer = nil, func = :update, &block)
+        observers.add_observer(observer, func, &block)
       end
 
-      # as #add_observer but it can be used for chaining
+      # As `#add_observer` but can be used for chaining.
+      #
+      # @param [Object] observer the observer to add
+      # @param [Symbol] func the function to call on the observer during notification.
       # @return [Observable] self
-      def with_observer(*args, &block)
-        add_observer(*args, &block)
+      def with_observer(observer = nil, func = :update, &block)
+        add_observer(observer, func, &block)
         self
       end
 
-      # @return [Object] the deleted observer
-      def delete_observer(*args)
-        observers.delete_observer(*args)
+      # @!macro [attach] observable_delete_observer
+      # 
+      #   Remove `observer` as an observer on this object so that it will no
+      #   longer receive notifications.
+      #
+      #   @param [Object] observer the observer to remove
+      #   @return [Object] the deleted observer
+      def delete_observer(observer)
+        observers.delete_observer(observer)
       end
 
-      # @return [Observable] self
+      # @!macro [attach] observable_delete_observers
+      # 
+      #   Remove all observers associated with this object.
+      #   
+      #   @return [Observable] self
       def delete_observers
         observers.delete_observers
         self
       end
 
-      # @return [Integer] the observers count
+      # @!macro [attach] observable_count_observers
+      #
+      #   Return the number of observers associated with this object.
+      #
+      #   @return [Integer] the observers count
       def count_observers
         observers.count_observers
       end

data/lib/concurrent/configuration.rb

@@ -2,18 +2,17 @@ require 'thread'
 require 'concurrent/delay'
 require 'concurrent/errors'
 require 'concurrent/atomic/atomic_reference'
-require 'concurrent/concern/deprecation'
 require 'concurrent/concern/logging'
-require 'concurrent/executor/timer_set'
 require 'concurrent/executor/immediate_executor'
-require 'concurrent/executor/fixed_thread_pool'
-require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/utility/at_exit'
 require 'concurrent/utility/processor_counter'
 
 module Concurrent
   extend Concern::Logging
-  extend Concern::Deprecation
+
+  autoload :Options,            'concurrent/options'
+  autoload :TimerSet,           'concurrent/executor/timer_set'
+  autoload :ThreadPoolExecutor, 'concurrent/executor/thread_pool_executor'
 
   # @return [Logger] Logger with provided level and output.
   def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
@@ -25,19 +24,19 @@ module Concurrent
                             msg
                           when Exception
                             format "%s (%s)\n%s",
-                                   msg.message, msg.class, (msg.backtrace || []).join("\n")
+                              msg.message, msg.class, (msg.backtrace || []).join("\n")
                           else
                             msg.inspect
                           end
       format "[%s] %5s -- %s: %s\n",
-             datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
-             severity,
-             progname,
-             formatted_message
+        datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
+        severity,
+        progname,
+        formatted_message
     end
 
     lambda do |loglevel, progname, message = nil, &block|
-      logger.add loglevel, message, progname, &block
+    logger.add loglevel, message, progname, &block
     end
   end
 
@@ -95,25 +94,6 @@ module Concurrent
     AtExit.enabled = false
   end
 
-  def self.disable_executor_auto_termination!
-    deprecated_method 'disable_executor_auto_termination!', 'disable_at_exit_handlers!'
-    disable_at_exit_handlers!
-  end
-
-  # @return [true,false]
-  # @see .disable_executor_auto_termination!
-  def self.disable_executor_auto_termination?
-    deprecated_method 'disable_executor_auto_termination?', 'Concurrent::AtExit.enabled?'
-    AtExit.enabled?
-  end
-
-  # terminates all pools and blocks until they are terminated
-  # @see .disable_executor_auto_termination!
-  def self.terminate_pools!
-    deprecated_method 'terminate_pools!', 'Concurrent::AtExit.run'
-    AtExit.run
-  end
-
   # Global thread pool optimized for short, fast *operations*.
   #
   # @return [ThreadPoolExecutor] the thread pool
@@ -146,137 +126,28 @@ module Concurrent
   #   - :immediate - {Concurrent.global_immediate_executor}
   # @return [Executor]
   def self.executor(executor_identifier)
-    Executor.executor(executor_identifier)
+    Options.executor(executor_identifier)
   end
 
   def self.new_fast_executor(opts = {})
     FixedThreadPool.new(
-        [2, Concurrent.processor_count].max,
-        auto_terminate:  opts.fetch(:auto_terminate, true),
-        idletime:        60, # 1 minute
-        max_queue:       0, # unlimited
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
+      [2, Concurrent.processor_count].max,
+      auto_terminate:  opts.fetch(:auto_terminate, true),
+      idletime:        60, # 1 minute
+      max_queue:       0, # unlimited
+      fallback_policy: :abort # shouldn't matter -- 0 max queue
     )
   end
 
   def self.new_io_executor(opts = {})
     ThreadPoolExecutor.new(
-        min_threads:     [2, Concurrent.processor_count].max,
-        max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
-        # max_threads:     1000,
-        auto_terminate:  opts.fetch(:auto_terminate, true),
-        idletime:        60, # 1 minute
-        max_queue:       0, # unlimited
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
+      min_threads:     [2, Concurrent.processor_count].max,
+      max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
+      # max_threads:     1000,
+      auto_terminate:  opts.fetch(:auto_terminate, true),
+      idletime:        60, # 1 minute
+      max_queue:       0, # unlimited
+      fallback_policy: :abort # shouldn't matter -- 0 max queue
     )
   end
-
-  # A gem-level configuration object.
-  class Configuration
-    include Concern::Deprecation
-
-    # Create a new configuration object.
-    def initialize
-    end
-
-    # if assigned to {#logger}, it will log nothing.
-    # @deprecated Use Concurrent::NULL_LOGGER instead
-    def no_logger
-      deprecated_method 'Concurrent.configuration.no_logger', 'Concurrent::NULL_LOGGER'
-      NULL_LOGGER
-    end
-
-    # a proc defining how to log messages, its interface has to be:
-    #   lambda { |level, progname, message = nil, &block| _ }
-    #
-    # @deprecated Use Concurrent.global_logger instead
-    def logger
-      deprecated_method 'Concurrent.configuration.logger', 'Concurrent.global_logger'
-      Concurrent.global_logger.value
-    end
-
-    # a proc defining how to log messages, its interface has to be:
-    #   lambda { |level, progname, message = nil, &block| _ }
-    #
-    # @deprecated Use Concurrent.global_logger instead
-    def logger=(value)
-      deprecated_method 'Concurrent.configuration.logger=', 'Concurrent.global_logger='
-      Concurrent.global_logger = value
-    end
-
-    # @deprecated Use Concurrent.global_io_executor instead
-    def global_task_pool
-      deprecated_method 'Concurrent.configuration.global_task_pool', 'Concurrent.global_io_executor'
-      Concurrent.global_io_executor
-    end
-
-    # @deprecated Use Concurrent.global_fast_executor instead
-    def global_operation_pool
-      deprecated_method 'Concurrent.configuration.global_operation_pool', 'Concurrent.global_fast_executor'
-      Concurrent.global_fast_executor
-    end
-
-    # @deprecated Use Concurrent.global_timer_set instead
-    def global_timer_set
-      deprecated_method 'Concurrent.configuration.global_timer_set', 'Concurrent.global_timer_set'
-      Concurrent.global_timer_set
-    end
-
-    # @deprecated Replacing global thread pools is deprecated.
-    #   Use the :executor constructor option instead.
-    def global_task_pool=(executor)
-      deprecated 'Replacing global thread pools is deprecated. Use the :executor constructor option instead.'
-      GLOBAL_IO_EXECUTOR.reconfigure { executor } or
-          raise ConfigurationError.new('global task pool was already set')
-    end
-
-    # @deprecated Replacing global thread pools is deprecated.
-    #   Use the :executor constructor option instead.
-    def global_operation_pool=(executor)
-      deprecated 'Replacing global thread pools is deprecated. Use the :executor constructor option instead.'
-      GLOBAL_FAST_EXECUTOR.reconfigure { executor } or
-          raise ConfigurationError.new('global operation pool was already set')
-    end
-
-    # @deprecated Use Concurrent.new_io_executor instead
-    def new_task_pool
-      deprecated_method 'Concurrent.configuration.new_task_pool', 'Concurrent.new_io_executor'
-      Concurrent.new_io_executor
-    end
-
-    # @deprecated Use Concurrent.new_fast_executor instead
-    def new_operation_pool
-      deprecated_method 'Concurrent.configuration.new_operation_pool', 'Concurrent.new_fast_executor'
-      Concurrent.new_fast_executor
-    end
-
-    # @deprecated Use Concurrent.disable_executor_auto_termination! instead
-    def auto_terminate=(value)
-      deprecated_method 'Concurrent.configuration.auto_terminate=', 'Concurrent.disable_executor_auto_termination!'
-      Concurrent.disable_executor_auto_termination! if !value
-    end
-
-    # @deprecated Use Concurrent.auto_terminate_global_executors? instead
-    def auto_terminate
-      deprecated_method 'Concurrent.configuration.auto_terminate', 'Concurrent.auto_terminate_global_executors?'
-      Concurrent.auto_terminate_global_executors?
-    end
-  end
-
-  # create the default configuration on load
-  CONFIGURATION = AtomicReference.new(Configuration.new)
-  private_constant :CONFIGURATION
-
-  # @return [Configuration]
-  def self.configuration
-    CONFIGURATION.value
-  end
-
-  # Perform gem-level configuration.
-  #
-  # @yield the configuration commands
-  # @yieldparam [Configuration] the current configuration object
-  def self.configure
-    yield(configuration)
-  end
 end