Merge pull request #409 from ruby-concurrency/circular

Fix interpreter warnings

Author: jdantonio

lib/concurrent.rb

@@ -1,12 +1,10 @@
 require 'concurrent/version'
-
-require 'concurrent/synchronization'
-
 require 'concurrent/configuration'
 
 require 'concurrent/atomics'
 require 'concurrent/errors'
 require 'concurrent/executors'
+require 'concurrent/synchronization'
 
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/atom'
@@ -33,6 +31,7 @@
 require 'concurrent/thread_safe/synchronized_delegator'
 require 'concurrent/thread_safe/util'
 
+require 'concurrent/options'
 
 # @!macro [new] internal_implementation_note
 #

lib/concurrent/agent.rb

@@ -2,11 +2,12 @@
 require 'concurrent/concern/dereferenceable'
 require 'concurrent/concern/observable'
 require 'concurrent/concern/logging'
-require 'concurrent/executor/executor'
 require 'concurrent/synchronization'
 
 module Concurrent
 
+  autoload :Options, 'concurrent/options'
+
   # `Agent`s are inspired by [Clojure's](http://clojure.org/) [agent](http://clojure.org/agents) function. An `Agent` is a single atomic value that represents an identity. The current value of the `Agent` can be requested at any time (`deref`). Each `Agent` has a work queue and operates on the global thread pool (see below). Consumers can `post` code blocks to the `Agent`. The code block (function) will receive the current value of the `Agent` as its sole parameter. The return value of the block will become the new value of the `Agent`. `Agent`s support two error handling modes: fail and continue. A good example of an `Agent` is a shared incrementing counter, such as the score in a video game. 
   # 
   # An `Agent` must be initialize with an initial value. This value is always accessible via the `value` (or `deref`) methods. Code blocks sent to the `Agent` will be processed in the order received. As each block is processed the current value is updated with the result from the block. This update is an atomic operation so a `deref` will never block and will always return the current value. 
@@ -203,8 +204,8 @@ def ns_initialize(initial, opts)
       @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
+      @io_executor          = Options.executor_from_options(opts) || Concurrent.global_io_executor
+      @fast_executor        = Options.executor_from_options(opts) || Concurrent.global_fast_executor
       set_deref_options(opts)
     end
 

lib/concurrent/array.rb

@@ -27,6 +27,7 @@ class Array < ::Array
 
   elsif Concurrent.on_rbx?
     require 'monitor'
+    require 'concurrent/thread_safe/util/array_hash_rbx'
 
     # @!macro concurrent_array
     class Array < ::Array

lib/concurrent/collection/map/atomic_reference_map_backend.rb

@@ -1,4 +1,9 @@
 require 'concurrent/thread_safe/util'
+require 'concurrent/thread_safe/util/adder'
+require 'concurrent/thread_safe/util/cheap_lockable'
+require 'concurrent/thread_safe/util/power_of_two_tuple'
+require 'concurrent/thread_safe/util/volatile'
+require 'concurrent/thread_safe/util/xor_shift_random'
 
 module Concurrent
 

lib/concurrent/configuration.rb

@@ -3,16 +3,17 @@
 require 'concurrent/errors'
 require 'concurrent/atomic/atomic_reference'
 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
 
+  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)
     logger           = Logger.new(output)
@@ -125,7 +126,7 @@ def self.global_timer_set
   #   - :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 = {})

lib/concurrent/delay.rb

@@ -1,12 +1,12 @@
 require 'thread'
-require 'concurrent/configuration'
 require 'concurrent/concern/obligation'
-require 'concurrent/executor/executor'
 require 'concurrent/executor/immediate_executor'
 require 'concurrent/synchronization'
 
 module Concurrent
 
+  autoload :Options, 'concurrent/options'
+
   # Lazy evaluation of a block yielding an immutable result. Useful for
   # expensive operations that may never be needed. It may be non-blocking,
   # supports the `Concern::Obligation` interface, and accepts the injection of
@@ -74,7 +74,7 @@ def initialize(opts = {}, &block)
     #
     # @!macro delay_note_regarding_blocking
     def value(timeout = nil)
-      if @task_executor
+      if @executor
         super
       else
         # this function has been optimized for performance and
@@ -108,7 +108,7 @@ def value(timeout = nil)
     #
     # @!macro delay_note_regarding_blocking
     def value!(timeout = nil)
-      if @task_executor
+      if @executor
         super
       else
         result = value
@@ -127,7 +127,7 @@ def value!(timeout = nil)
     #
     # @!macro delay_note_regarding_blocking
     def wait(timeout = nil)
-      if @task_executor
+      if @executor
         execute_task_once
         super(timeout)
       else
@@ -157,7 +157,7 @@ def reconfigure(&block)
     def ns_initialize(opts, &block)
       init_obligation(self)
       set_deref_options(opts)
-      @task_executor = Executor.executor_from_options(opts)
+      @executor = opts[:executor]
 
       @task      = block
       @state     = :pending
@@ -177,7 +177,8 @@ def execute_task_once # :nodoc:
       end
 
       if execute
-        @task_executor.post do
+        executor = Options.executor_from_options(executor: @executor)
+        executor.post do
           begin
             result  = task.call
             success = true

lib/concurrent/executor/ruby_executor_service.rb

@@ -51,7 +51,13 @@ def wait_for_termination(timeout = nil)
 
     private
 
-    attr_reader :stop_event, :stopped_event
+    def stop_event
+      @stop_event
+    end
+
+    def stopped_event
+      @stopped_event
+    end
 
     def ns_shutdown_execution
       stopped_event.set

lib/concurrent/executor/timer_set.rb

@@ -6,6 +6,8 @@
 
 module Concurrent
 
+  autoload :Options, 'concurrent/options'
+
   # Executes a collection of tasks, each after a given delay. A master task
   # monitors the set and schedules each task for execution at the appropriate
   # time. Tasks are run on the global thread pool or on the supplied executor.
@@ -73,7 +75,7 @@ def kill
     # @!visibility private
     def ns_initialize(opts)
       @queue          = Collection::NonConcurrentPriorityQueue.new(order: :min)
-      @task_executor  = Executor.executor_from_options(opts) || Concurrent.global_io_executor
+      @task_executor  = Options.executor_from_options(opts) || Concurrent.global_io_executor
       @timer_executor = SingleThreadExecutor.new
       @condition      = Event.new
       self.auto_terminate = opts.fetch(:auto_terminate, true)
@@ -115,7 +117,7 @@ def remove_task(task)
       synchronize{ @queue.delete(task) }
     end
 
-    # `ExecutorServic` callback called during shutdown.
+    # `ExecutorService` callback called during shutdown.
     #
     # @!visibility private
     def ns_shutdown_execution

lib/concurrent/executors.rb

@@ -1,6 +1,5 @@
 require 'concurrent/executor/abstract_executor_service'
 require 'concurrent/executor/cached_thread_pool'
-require 'concurrent/executor/executor'
 require 'concurrent/executor/executor_service'
 require 'concurrent/executor/fixed_thread_pool'
 require 'concurrent/executor/immediate_executor'

lib/concurrent/future.rb

@@ -1,11 +1,12 @@
 require 'thread'
 require 'concurrent/errors'
 require 'concurrent/ivar'
-require 'concurrent/executor/executor'
 require 'concurrent/executor/safe_task_executor'
 
 module Concurrent
 
+  autoload :Options, 'concurrent/options'
+
   # {include:file:doc/future.md}
   #
   # @!macro copy_options
@@ -129,7 +130,7 @@ def ns_initialize(value, opts)
       super
       @state = :unscheduled
       @task = opts[:__task_from_block__]
-      @executor = Executor.executor_from_options(opts) || Concurrent.global_io_executor
+      @executor = Options.executor_from_options(opts) || Concurrent.global_io_executor
       @args = get_arguments_from(opts)
     end
   end