concurrent-ruby 1.0.5 → 1.1.6

data/lib/{concurrent → concurrent-ruby/concurrent}/concern/dereferenceable.rb

@@ -32,13 +32,13 @@ module Concurrent
         synchronize{ @value = value }
       end
 
-      # @!macro [attach] dereferenceable_set_deref_options
+      # @!macro 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.
+      #     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

data/lib/{concurrent → concurrent-ruby/concurrent}/concern/logging.rb

@@ -17,7 +17,12 @@ module Concurrent
       def log(level, progname, message = nil, &block)
         #NOTE: Cannot require 'concurrent/configuration' above due to circular references.
         #      Assume that the gem has been initialized if we've gotten this far.
-        (@logger || Concurrent.global_logger).call level, progname, message, &block
+        logger = if defined?(@logger) && @logger
+                   @logger
+                 else
+                   Concurrent.global_logger
+                 end
+        logger.call level, progname, message, &block
       rescue => error
         $stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
           "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"

data/lib/{concurrent → concurrent-ruby/concurrent}/concern/observable.rb

@@ -49,7 +49,7 @@ module Concurrent
     # or an AtomicFixum)
     module Observable
 
-      # @!macro [attach] observable_add_observer
+      # @!macro 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.
@@ -72,8 +72,8 @@ module Concurrent
         self
       end
 
-      # @!macro [attach] observable_delete_observer
-      # 
+      # @!macro observable_delete_observer
+      #
       #   Remove `observer` as an observer on this object so that it will no
       #   longer receive notifications.
       #
@@ -83,17 +83,17 @@ module Concurrent
         observers.delete_observer(observer)
       end
 
-      # @!macro [attach] observable_delete_observers
-      # 
+      # @!macro observable_delete_observers
+      #
       #   Remove all observers associated with this object.
-      #   
+      #
       #   @return [Observable] self
       def delete_observers
         observers.delete_observers
         self
       end
 
-      # @!macro [attach] observable_count_observers
+      # @!macro observable_count_observers
       #
       #   Return the number of observers associated with this object.
       #

data/lib/{concurrent → concurrent-ruby/concurrent}/configuration.rb

@@ -3,12 +3,14 @@ require 'concurrent/delay'
 require 'concurrent/errors'
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/concern/logging'
+require 'concurrent/concern/deprecation'
 require 'concurrent/executor/immediate_executor'
-require 'concurrent/utility/at_exit'
+require 'concurrent/executor/cached_thread_pool'
 require 'concurrent/utility/processor_counter'
 
 module Concurrent
   extend Concern::Logging
+  extend Concern::Deprecation
 
   autoload :Options, 'concurrent/options'
   autoload :TimerSet, 'concurrent/executor/timer_set'
@@ -96,15 +98,15 @@ module Concurrent
   end
 
   # @!visibility private
-  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor(auto_terminate: true) }
+  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor }
   private_constant :GLOBAL_FAST_EXECUTOR
 
   # @!visibility private
-  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor(auto_terminate: true) }
+  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor }
   private_constant :GLOBAL_IO_EXECUTOR
 
   # @!visibility private
-  GLOBAL_TIMER_SET = Delay.new { TimerSet.new(auto_terminate: true) }
+  GLOBAL_TIMER_SET = Delay.new { TimerSet.new }
   private_constant :GLOBAL_TIMER_SET
 
   # @!visibility private
@@ -114,7 +116,7 @@ module Concurrent
   # Disables AtExit handlers including pool auto-termination handlers.
   # When disabled it will be the application programmer's responsibility
   # to ensure that the handlers are shutdown properly prior to application
-  # exit by calling {AtExit.run} method.
+  # exit by calling `AtExit.run` method.
   #
   # @note this option should be needed only because of `at_exit` ordering
   #   issues which may arise when running some of the testing frameworks.
@@ -124,9 +126,10 @@ module Concurrent
   # @note This method should *never* be called
   #   from within a gem. It should *only* be used from within the main
   #   application and even then it should be used only when necessary.
-  # @see AtExit
+  # @deprecated Has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841.
+  #
   def self.disable_at_exit_handlers!
-    AtExit.enabled = false
+    deprecated "Method #disable_at_exit_handlers! has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841."
   end
 
   # Global thread pool optimized for short, fast *operations*.
@@ -170,19 +173,16 @@ module Concurrent
         auto_terminate:  opts.fetch(:auto_terminate, true),
         idletime:        60, # 1 minute
         max_queue:       0, # unlimited
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "fast"
     )
   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,
+    CachedThreadPool.new(
         auto_terminate:  opts.fetch(:auto_terminate, true),
-        idletime:        60, # 1 minute
-        max_queue:       0, # unlimited
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "io"
     )
   end
 end

data/lib/{concurrent → concurrent-ruby/concurrent}/constants.rb

@@ -3,6 +3,6 @@ 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
+  NULL = ::Object.new
 
 end

data/lib/{concurrent → concurrent-ruby/concurrent}/dataflow.rb

@@ -18,7 +18,8 @@ module Concurrent
     end
   end
 
-  # {include:file:doc/dataflow.md}
+  # Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
+  # {include:file:docs-source/dataflow.md}
   #
   # @param [Future] inputs zero or more `Future` operations that this dataflow depends upon
   #

data/lib/{concurrent → concurrent-ruby/concurrent}/delay.rb

@@ -32,7 +32,7 @@ module Concurrent
   #
   # @!macro copy_options
   #
-  # @!macro [attach] delay_note_regarding_blocking
+  # @!macro delay_note_regarding_blocking
   #   @note The default behavior of `Delay` is to block indefinitely when
   #     calling either `value` or `wait`, executing the delayed operation on
   #     the current thread. This makes the `timeout` value completely
@@ -81,13 +81,15 @@ module Concurrent
         # this function has been optimized for performance and
         # should not be modified without running new benchmarks
         synchronize do
-          execute = @computing = true unless @computing
+          execute = @evaluation_started = true unless @evaluation_started
           if execute
             begin
               set_state(true, @task.call, nil)
             rescue => ex
               set_state(false, nil, ex)
             end
+          elsif incomplete?
+            raise IllegalOperationError, 'Recursive call to #value during evaluation of the Delay'
           end
         end
         if @do_nothing_on_deref
@@ -144,7 +146,7 @@ module Concurrent
     def reconfigure(&block)
       synchronize do
         raise ArgumentError.new('no block given') unless block_given?
-        unless @computing
+        unless @evaluation_started
           @task = block
           true
         else
@@ -160,9 +162,9 @@ module Concurrent
       set_deref_options(opts)
       @executor = opts[:executor]
 
-      @task      = block
-      @state     = :pending
-      @computing = false
+      @task               = block
+      @state              = :pending
+      @evaluation_started = false
     end
 
     private
@@ -173,7 +175,7 @@ module Concurrent
       # should not be modified without running new benchmarks
       execute = task = nil
       synchronize do
-        execute = @computing = true unless @computing
+        execute = @evaluation_started = true unless @evaluation_started
         task    = @task
       end
 

data/lib/{concurrent → concurrent-ruby/concurrent}/exchanger.rb

@@ -8,7 +8,7 @@ require 'concurrent/utility/monotonic_time'
 
 module Concurrent
 
-  # @!macro [attach] exchanger
+  # @!macro exchanger
   #
   #   A synchronization point at which threads can pair and swap elements within
   #   pairs. Each thread presents some object on entry to the exchange method,
@@ -24,9 +24,6 @@ module Concurrent
   #   will remain correct.
   #
   #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Exchanger.html java.util.concurrent.Exchanger
-  #
-  #   @!macro edge_warning
-  #
   #   @example
   #
   #     exchanger = Concurrent::Exchanger.new
@@ -36,20 +33,19 @@ module Concurrent
   #       Thread.new { puts "second: " << exchanger.exchange('bar', 1) } #=> "second: foo"
   #     ]
   #     threads.each {|t| t.join(2) }
-  #
+
   # @!visibility private
   class AbstractExchanger < Synchronization::Object
 
     # @!visibility private
-    CANCEL = Object.new
+    CANCEL = ::Object.new
     private_constant :CANCEL
 
-    # @!macro [attach] exchanger_method_initialize
     def initialize
       super
     end
 
-    # @!macro [attach] exchanger_method_do_exchange
+    # @!macro exchanger_method_do_exchange
     #
     #   Waits for another thread to arrive at this exchange point (unless the
     #   current thread is interrupted), and then transfers the given object to
@@ -61,7 +57,7 @@ module Concurrent
     #   @param [Object] value the value to exchange with another thread
     #   @param [Numeric, nil] timeout in seconds, `nil` blocks indefinitely
     #
-    # @!macro [attach] exchanger_method_exchange
+    # @!macro exchanger_method_exchange
     #
     #   In some edge cases when a `timeout` is given a return value of `nil` may be
     #   ambiguous. Specifically, if `nil` is a valid value in the exchange it will
@@ -75,8 +71,7 @@ module Concurrent
     end
 
     # @!macro exchanger_method_do_exchange
-    #
-    # @!macro [attach] exchanger_method_exchange_bang
+    # @!macro exchanger_method_exchange_bang
     #
     #   On timeout a {Concurrent::TimeoutError} exception will be raised.
     #
@@ -91,8 +86,7 @@ module Concurrent
     end
 
     # @!macro exchanger_method_do_exchange
-    #
-    # @!macro [attach] exchanger_method_try_exchange
+    # @!macro exchanger_method_try_exchange
     #
     #   The return value will be a {Concurrent::Maybe} set to `Just` on success or
     #   `Nothing` on timeout.
@@ -130,7 +124,6 @@ module Concurrent
     end
   end
 
-  # @!macro exchanger
   # @!macro internal_implementation_note
   # @!visibility private
   class RubyExchanger < AbstractExchanger
@@ -148,8 +141,8 @@ module Concurrent
 
       def initialize(item)
         super()
-        @Item = item
-        @Latch = Concurrent::CountDownLatch.new
+        @Item      = item
+        @Latch     = Concurrent::CountDownLatch.new
         self.value = nil
       end
 
@@ -163,7 +156,6 @@ module Concurrent
     end
     private_constant :Node
 
-    # @!macro exchanger_method_initialize
     def initialize
       super
     end
@@ -218,7 +210,7 @@ module Concurrent
       # node's initial value. It never changes. It's what the fulfiller returns on
       # success. The occupier's hole is where the fulfiller put its item. It's the
       # item that the occupier returns on success. The latch is used for synchronization.
-      # Becuase a thread may act as either an occupier or fulfiller (or possibly
+      # Because a thread may act as either an occupier or fulfiller (or possibly
       # both in periods of high contention) every thread creates a node when
       # the exchange method is first called.
       #
@@ -260,8 +252,8 @@ module Concurrent
       #     - Wake the sleeping occupier
       #     - Return the occupier's item
 
-      value = NULL if value.nil?                        # The sentinel allows nil to be a valid value
-      me = Node.new(value)                              # create my node in case I need to occupy
+      value  = NULL if value.nil? # The sentinel allows nil to be a valid value
+      me     = Node.new(value) # create my node in case I need to occupy
       end_at = Concurrent.monotonic_time + timeout.to_f # The time to give up
 
       result = loop do
@@ -298,12 +290,10 @@ module Concurrent
 
   if Concurrent.on_jruby?
 
-    # @!macro exchanger
     # @!macro internal_implementation_note
     # @!visibility private
     class JavaExchanger < AbstractExchanger
 
-      # @!macro exchanger_method_initialize
       def initialize
         @exchanger = java.util.concurrent.Exchanger.new
       end
@@ -314,11 +304,17 @@ module Concurrent
       #
       # @return [Object, CANCEL] the value exchanged by the other thread; {CANCEL} on timeout
       def do_exchange(value, timeout)
+        result = nil
         if timeout.nil?
-          @exchanger.exchange(value)
+          Synchronization::JRuby.sleep_interruptibly do
+            result = @exchanger.exchange(value)
+          end
         else
-          @exchanger.exchange(value, 1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          Synchronization::JRuby.sleep_interruptibly do
+            result = @exchanger.exchange(value, 1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          end
         end
+        result
       rescue java.util.concurrent.TimeoutException
         CANCEL
       end
@@ -339,7 +335,7 @@ module Concurrent
   class Exchanger < ExchangerImplementation
 
     # @!method initialize
-    #   @!macro exchanger_method_initialize
+    #   Creates exchanger instance
 
     # @!method exchange(value, timeout = nil)
     #   @!macro exchanger_method_do_exchange

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/abstract_executor_service.rb

@@ -1,7 +1,7 @@
 require 'concurrent/errors'
+require 'concurrent/concern/deprecation'
 require 'concurrent/executor/executor_service'
 require 'concurrent/synchronization'
-require 'concurrent/utility/at_exit'
 
 module Concurrent
 
@@ -9,6 +9,7 @@ module Concurrent
   # @!visibility private
   class AbstractExecutorService < Synchronization::LockableObject
     include ExecutorService
+    include Concern::Deprecation
 
     # The set of possible fallback policies that may be set at thread pool creation.
     FALLBACK_POLICIES = [:abort, :discard, :caller_runs].freeze
@@ -16,10 +17,20 @@ module Concurrent
     # @!macro executor_service_attr_reader_fallback_policy
     attr_reader :fallback_policy
 
+    attr_reader :name
+
     # Create a new thread pool.
-    def initialize(*args, &block)
+    def initialize(opts = {}, &block)
       super(&nil)
-      synchronize { ns_initialize(*args, &block) }
+      synchronize do
+        @auto_terminate = opts.fetch(:auto_terminate, true)
+        @name = opts.fetch(:name) if opts.key?(:name)
+        ns_initialize(opts, &block)
+      end
+    end
+
+    def to_s
+      name ? "#{super[0..-2]} name: #{name}>" : super
     end
 
     # @!macro executor_service_method_shutdown
@@ -54,12 +65,12 @@ module Concurrent
 
     # @!macro executor_service_method_auto_terminate_question
     def auto_terminate?
-      synchronize { ns_auto_terminate? }
+      synchronize { @auto_terminate }
     end
 
     # @!macro executor_service_method_auto_terminate_setter
     def auto_terminate=(value)
-      synchronize { self.ns_auto_terminate = value }
+      deprecated "Method #auto_terminate= has no effect. Set :auto_terminate option when executor is initialized."
     end
 
     private
@@ -93,7 +104,7 @@ module Concurrent
       raise NotImplementedError
     end
 
-    # @!macro [attach] executor_service_method_ns_shutdown_execution
+    # @!macro executor_service_method_ns_shutdown_execution
     #
     #   Callback method called when an orderly shutdown has completed.
     #   The default behavior is to signal all waiting threads.
@@ -101,7 +112,7 @@ module Concurrent
       # do nothing
     end
 
-    # @!macro [attach] executor_service_method_ns_kill_execution
+    # @!macro executor_service_method_ns_kill_execution
     #
     #   Callback method called when the executor has been killed.
     #   The default behavior is to do nothing.
@@ -110,25 +121,8 @@ module Concurrent
     end
 
     def ns_auto_terminate?
-      !!@auto_terminate
+      @auto_terminate
     end
 
-    def ns_auto_terminate=(value)
-      case value
-      when true
-        AtExit.add(self) { terminate_at_exit }
-        @auto_terminate = true
-      when false
-        AtExit.delete(self)
-        @auto_terminate = false
-      else
-        raise ArgumentError
-      end
-    end
-
-    def terminate_at_exit
-      kill # TODO be gentle first
-      wait_for_termination(10)
-    end
   end
 end